001/* 002 * To change this template, choose Tools | Templates 003 * and open the template in the editor. 004 */ 005package armyc2.c2sd.JavaTacticalRenderer; 006 007import armyc2.c2sd.JavaLineArray.TacticalLines; 008import armyc2.c2sd.JavaLineArray.arraysupport; 009import armyc2.c2sd.JavaLineArray.lineutility; 010import armyc2.c2sd.JavaLineArray.CELineArray; 011import armyc2.c2sd.JavaLineArray.POINT2; 012import java.util.ArrayList; 013import armyc2.c2sd.JavaLineArray.Shape2; 014import armyc2.c2sd.renderer.utilities.Color; 015import armyc2.c2sd.graphics2d.*; 016import java.io.InputStream; 017import armyc2.c2sd.renderer.utilities.ErrorLogger; 018import armyc2.c2sd.renderer.utilities.RendererException; 019import armyc2.c2sd.renderer.utilities.ShapeInfo; 020 021/** 022 * Class to calculate the points for the Weather symbols 023 * @author Michael Deutch 024 */ 025public final class clsMETOC { 026 private static final String _className = "clsMETOC"; 027 //the following functions are for the rev D symbols 028 /** 029 * Rev D METOC symbols 030 * @param SymbolSet 031 * @param entityCode 032 * @return 033 */ 034 public static int getWeatherLinetype(String SymbolSet, String entityCode) 035 { 036 int symbolSet=Integer.parseInt(SymbolSet); 037 if(symbolSet != 45 && symbolSet != 46) 038 return -1; 039 int nCode=Integer.parseInt(entityCode); 040 switch(nCode) 041 { 042 case 110301: 043 return TacticalLines.CF; 044 case 110302: 045 return TacticalLines.UCF; 046 case 110303: 047 return TacticalLines.CFG; 048 case 110304: 049 return TacticalLines.CFY; 050 case 110305: 051 return TacticalLines.WF; 052 case 110306: 053 return TacticalLines.UWF; 054 case 110307: 055 return TacticalLines.WFG; 056 case 110308: 057 return TacticalLines.WFY; 058 case 110309: 059 return TacticalLines.OCCLUDED; 060 case 110310: 061 return TacticalLines.UOF; 062 case 110311: 063 return TacticalLines.OFY; 064 case 110312: 065 return TacticalLines.SF; 066 case 110313: 067 return TacticalLines.USF; 068 case 110314: 069 return TacticalLines.SFG; 070 case 110315: 071 return TacticalLines.SFY; 072 case 110401: //trough with dashed lines new symbol 073 case 110402: //now called upper trough 074 return TacticalLines.TROUGH; 075 case 110403: 076 return TacticalLines.RIDGE; 077 case 110404: 078 return TacticalLines.SQUALL; 079 case 110405: 080 return TacticalLines.INSTABILITY; 081 case 110406: 082 return TacticalLines.SHEAR; 083 case 110407: 084 return TacticalLines.ITC; 085 case 110408: 086 return TacticalLines.CONVERGANCE; 087 case 110409: 088 return TacticalLines.ITD; 089 case 140300: 090 return TacticalLines.JET; 091 case 140400: 092 return TacticalLines.STREAM; 093 case 162004: //tropical storm wind 094 break; 095 case 170100: 096 return TacticalLines.IFR; 097 case 170200: 098 return TacticalLines.MVFR; 099 case 170300: 100 return TacticalLines.TURBULENCE; 101 case 170400: 102 return TacticalLines.ICING; 103 case 170500: 104 return TacticalLines.NON_CONVECTIVE; 105 case 170501: 106 return TacticalLines.CONVECTIVE; 107 case 170600: 108 return TacticalLines.FROZEN; 109 case 170700: 110 return TacticalLines.THUNDERSTORMS; 111 case 170800: 112 return TacticalLines.FOG; 113 case 170900: 114 return TacticalLines.SAND; 115 case 171000: 116 return TacticalLines.FREEFORM; 117 case 180100: 118 return TacticalLines.ISOBAR; 119 case 180200: 120 return TacticalLines.UPPER_AIR; 121 case 180300: 122 return TacticalLines.ISOTHERM; 123 case 180400: 124 return TacticalLines.ISOTACH; 125 case 180500: 126 return TacticalLines.ISODROSOTHERM; 127 case 180600: 128 return TacticalLines.ISOPLETHS; 129 case 180700: 130 return TacticalLines.OPERATOR_FREEFORM; 131 case 110501: 132 return TacticalLines.LVO; 133 case 110502: 134 return TacticalLines.UNDERCAST; 135 case 110503: 136 return TacticalLines.LRO; 137 case 110504: 138 return TacticalLines.ICE_EDGE; 139 case 110505: 140 return TacticalLines.ESTIMATED_ICE_EDGE; 141 case 110506: 142 return TacticalLines.ICE_EDGE_RADAR; 143 case 110601: 144 return TacticalLines.CRACKS; 145 case 110602: 146 return TacticalLines.CRACKS_SPECIFIC_LOCATION; 147 case 110603: 148 return TacticalLines.ICE_OPENINGS_LEAD; 149 case 110604: 150 return TacticalLines.ICE_OPENINGS_FROZEN; 151 case 120102: 152 return TacticalLines.DEPTH_CURVE; 153 case 120103: 154 return TacticalLines.DEPTH_CONTOUR; 155 case 120104: 156 return TacticalLines.DEPTH_AREA; 157 case 120201: 158 return TacticalLines.COASTLINE; 159 case 120202: 160 return TacticalLines.ISLAND; 161 case 120203: 162 return TacticalLines.BEACH; 163 case 120204: 164 return TacticalLines.WATER; 165 case 120205: 166 return TacticalLines.FORESHORE_LINE; 167 case 120206: 168 return TacticalLines.FORESHORE_AREA; 169 case 120305: 170 return TacticalLines.ANCHORAGE_LINE; 171 case 120306: 172 return TacticalLines.ANCHORAGE_AREA; 173 174 case 120308: 175 return TacticalLines.PIER; 176 case 120312: 177 return TacticalLines.WEIRS; 178 case 120313: 179 return TacticalLines.DRYDOCK; 180 case 120317: 181 return TacticalLines.LOADING_FACILITY_LINE; 182 case 120318: 183 return TacticalLines.LOADING_FACILITY_AREA; 184 185 case 120319: 186 return TacticalLines.RAMP_ABOVE_WATER; 187 case 120320: 188 return TacticalLines.RAMP_BELOW_WATER; 189 190 case 120326: 191 return TacticalLines.JETTY_ABOVE_WATER; 192 case 120327: 193 return TacticalLines.JETTY_BELOW_WATER; 194 case 120328: 195 return TacticalLines.SEAWALL; 196 case 120405: 197 return TacticalLines.PERCHES; 198 case 120407: 199 return TacticalLines.LEADING_LINE; 200 case 120503: 201 return TacticalLines.UNDERWATER_HAZARD; 202 case 120505: 203 return TacticalLines.FOUL_GROUND; 204 case 120507: 205 return TacticalLines.KELP; 206 case 120511: 207 return TacticalLines.BREAKERS; 208 case 120512: 209 return TacticalLines.REEF; 210 case 120514: 211 return TacticalLines.DISCOLORED_WATER; 212 case 120702: 213 return TacticalLines.EBB_TIDE; 214 case 120703: 215 return TacticalLines.FLOOD_TIDE; 216 217 case 130101: 218 return TacticalLines.VDR_LEVEL_12; 219 case 130102: 220 return TacticalLines.VDR_LEVEL_23; 221 case 130103: 222 return TacticalLines.VDR_LEVEL_34; 223 case 130104: 224 return TacticalLines.VDR_LEVEL_45; 225 case 130105: 226 return TacticalLines.VDR_LEVEL_56; 227 case 130106: 228 return TacticalLines.VDR_LEVEL_67; 229 case 130107: 230 return TacticalLines.VDR_LEVEL_78; 231 case 130108: 232 return TacticalLines.VDR_LEVEL_89; 233 case 130109: 234 return TacticalLines.VDR_LEVEL_910; 235 case 130201: 236 return TacticalLines.BEACH_SLOPE_FLAT; 237 case 130202: 238 return TacticalLines.BEACH_SLOPE_GENTLE; 239 case 130203: 240 return TacticalLines.BEACH_SLOPE_MODERATE; 241 case 130204: 242 return TacticalLines.BEACH_SLOPE_STEEP; 243 case 140101: 244 return TacticalLines.SOLID_ROCK; 245 case 140102: 246 return TacticalLines.CLAY; 247 case 140103: 248 return TacticalLines.VERY_COARSE_SAND; 249 case 140104: 250 return TacticalLines.COARSE_SAND; 251 case 140105: 252 return TacticalLines.MEDIUM_SAND; 253 case 140106: 254 return TacticalLines.FINE_SAND; 255 case 140107: 256 return TacticalLines.VERY_FINE_SAND; 257 case 140108: 258 return TacticalLines.VERY_FINE_SILT; 259 case 140109: 260 return TacticalLines.FINE_SILT; 261 case 140110: 262 return TacticalLines.MEDIUM_SILT; 263 case 140111: 264 return TacticalLines.COARSE_SILT; 265 case 140112: 266 return TacticalLines.BOULDERS; 267 case 140113: 268 return TacticalLines.OYSTER_SHELLS; 269 case 140114: 270 return TacticalLines.PEBBLES; 271 case 140115: 272 return TacticalLines.SAND_AND_SHELLS; 273 case 140116: 274 return TacticalLines.BOTTOM_SEDIMENTS_LAND; 275 case 140117: 276 return TacticalLines.BOTTOM_SEDIMENTS_NO_DATA; 277 case 140118: 278 return TacticalLines.BOTTOM_ROUGHNESS_SMOOTH; 279 case 140119: 280 return TacticalLines.BOTTOM_ROUGHNESS_MODERATE; 281 case 140120: 282 return TacticalLines.BOTTOM_ROUGHNESS_ROUGH; 283 case 140121: 284 return TacticalLines.CLUTTER_LOW; 285 case 140122: 286 return TacticalLines.CLUTTER_MEDIUM; 287 case 140123: 288 return TacticalLines.CLUTTER_HIGH; 289 case 140124: 290 return TacticalLines.IMPACT_BURIAL_0; 291 case 140125: 292 return TacticalLines.IMPACT_BURIAL_10; 293 case 140126: 294 return TacticalLines.IMPACT_BURIAL_20; 295 case 140127: 296 return TacticalLines.IMPACT_BURIAL_75; 297 case 140128: 298 return TacticalLines.IMPACT_BURIAL_100; 299 case 140129: 300 return TacticalLines.BOTTOM_CATEGORY_A; 301 case 140130: 302 return TacticalLines.BOTTOM_CATEGORY_B; 303 case 140131: 304 return TacticalLines.BOTTOM_CATEGORY_C; 305 case 140132: 306 return TacticalLines.BOTTOM_TYPE_A1; 307 case 140133: 308 return TacticalLines.BOTTOM_TYPE_A2; 309 case 140134: 310 return TacticalLines.BOTTOM_TYPE_A3; 311 case 140135: 312 return TacticalLines.BOTTOM_TYPE_B1; 313 case 140136: 314 return TacticalLines.BOTTOM_TYPE_B2; 315 case 140137: 316 return TacticalLines.BOTTOM_TYPE_B3; 317 case 140138: 318 return TacticalLines.BOTTOM_TYPE_C1; 319 case 140139: 320 return TacticalLines.BOTTOM_TYPE_C2; 321 case 140140: 322 return TacticalLines.BOTTOM_TYPE_C3; 323 324 case 150100: 325 return TacticalLines.MARITIME_LIMIT; 326 case 150200: 327 return TacticalLines.MARITIME_AREA; 328 case 150300: 329 return TacticalLines.RESTRICTED_AREA; 330 case 150400: 331 return TacticalLines.SWEPT_AREA; 332 case 150500: 333 return TacticalLines.TRAINING_AREA; 334 case 150600: 335 return TacticalLines.OPERATOR_DEFINED; 336 case 160100: 337 return TacticalLines.CABLE; 338 case 160200: 339 return TacticalLines.SUBMERGED_CRIB; 340 case 160300: 341 return TacticalLines.CANAL; 342 case 160700: 343 return TacticalLines.OIL_RIG_FIELD; 344 case 160800: 345 return TacticalLines.PIPE; 346 347 default: 348 return -1; 349 } 350 return -1; 351 } 352 /** 353 * @param symbolID Mil-Standard 2525 15 character code 354 * @return the line type as an integer if it is a weather symbol, else return -1 355 */ 356 public static int IsWeather(String symbolID) { 357 //the MeTOCs 358 try 359 { 360 //added section for revD 361 if(symbolID.length()>15) 362 { 363 //test for hold,brdghd 364 //String setA=Modifier2.getSetA(symbolID); 365 String setA=symbolID.substring(0,10); 366 //String setB=Modifier2.getSetB(symbolID); 367 String setB=symbolID.substring(10); 368 //String entityCode=Modifier2.getCode(setB); 369 String entityCode=setB.substring(0,6); 370 int nEntityCode=Integer.parseInt(entityCode); 371 //String symbolSet=Modifier2.getSymbolSet(setA); 372 String symbolSet=setA.substring(4,6); 373 int nSymbolSet=Integer.parseInt(symbolSet); 374 switch(nSymbolSet) 375 { 376 case 25: //look for holding line, bridgehead 377 if(nEntityCode==141400) 378 return TacticalLines.BRDGHD; 379 else if(nEntityCode==141500) 380 return TacticalLines.HOLD; 381 break; 382 case 45: 383 case 46: 384 return getWeatherLinetype(symbolSet,entityCode); 385 } 386 } 387 //end section 388 if(symbolID==null) 389 return -1; 390 if(symbolID.equalsIgnoreCase("HOLD")) 391 return TacticalLines.HOLD; 392 if(symbolID.equalsIgnoreCase("BRDGHD")) 393 return TacticalLines.BRDGHD; 394 395 if (symbolID.equalsIgnoreCase("CF")) { 396 return TacticalLines.CF; 397 } else if (symbolID.equalsIgnoreCase("BOTTOM_TYPE_C3")) { 398 return TacticalLines.BOTTOM_TYPE_C3; 399 } else if (symbolID.equalsIgnoreCase("BOTTOM_TYPE_C2")) { 400 return TacticalLines.BOTTOM_TYPE_C2; 401 } else if (symbolID.equalsIgnoreCase("BOTTOM_TYPE_C1")) { 402 return TacticalLines.BOTTOM_TYPE_C1; 403 } else if (symbolID.equalsIgnoreCase("BOTTOM_TYPE_B3")) { 404 return TacticalLines.BOTTOM_TYPE_B3; 405 } else if (symbolID.equalsIgnoreCase("BOTTOM_TYPE_B2")) { 406 return TacticalLines.BOTTOM_TYPE_B2; 407 } else if (symbolID.equalsIgnoreCase("BOTTOM_TYPE_B1")) { 408 return TacticalLines.BOTTOM_TYPE_B1; 409 } else if (symbolID.equalsIgnoreCase("BOTTOM_TYPE_A3")) { 410 return TacticalLines.BOTTOM_TYPE_A3; 411 } else if (symbolID.equalsIgnoreCase("BOTTOM_TYPE_A2")) { 412 return TacticalLines.BOTTOM_TYPE_A2; 413 } else if (symbolID.equalsIgnoreCase("BOTTOM_TYPE_A1")) { 414 return TacticalLines.BOTTOM_TYPE_A1; 415 } else if (symbolID.equalsIgnoreCase("BOTTOM_CATEGORY_C")) { 416 return TacticalLines.BOTTOM_CATEGORY_C; 417 } else if (symbolID.equalsIgnoreCase("BOTTOM_CATEGORY_B")) { 418 return TacticalLines.BOTTOM_CATEGORY_B; 419 } else if (symbolID.equalsIgnoreCase("BOTTOM_CATEGORY_A")) { 420 return TacticalLines.BOTTOM_CATEGORY_A; 421 } else if (symbolID.equalsIgnoreCase("IMPACT_BURIAL_100")) { 422 return TacticalLines.IMPACT_BURIAL_100; 423 } else if (symbolID.equalsIgnoreCase("IMPACT_BURIAL_75")) { 424 return TacticalLines.IMPACT_BURIAL_75; 425 } else if (symbolID.equalsIgnoreCase("IMPACT_BURIAL_20")) { 426 return TacticalLines.IMPACT_BURIAL_20; 427 } else if (symbolID.equalsIgnoreCase("IMPACT_BURIAL_10")) { 428 return TacticalLines.IMPACT_BURIAL_10; 429 } else if (symbolID.equalsIgnoreCase("IMPACT_BURIAL_0")) { 430 return TacticalLines.IMPACT_BURIAL_0; 431 } else if (symbolID.equalsIgnoreCase("CLUTTER_HIGH")) { 432 return TacticalLines.CLUTTER_HIGH; 433 } else if (symbolID.equalsIgnoreCase("CLUTTER_MEDIUM")) { 434 return TacticalLines.CLUTTER_MEDIUM; 435 } else if (symbolID.equalsIgnoreCase("CLUTTER_LOW")) { 436 return TacticalLines.CLUTTER_LOW; 437 } else if (symbolID.equalsIgnoreCase("BOTTOM_ROUGHNESS_ROUGH")) { 438 return TacticalLines.BOTTOM_ROUGHNESS_ROUGH; 439 } else if (symbolID.equalsIgnoreCase("BOTTOM_ROUGHNESS_MODERATE")) { 440 return TacticalLines.BOTTOM_ROUGHNESS_MODERATE; 441 } else if (symbolID.equalsIgnoreCase("BOTTOM_ROUGHNESS_SMOOTH")) { 442 return TacticalLines.BOTTOM_ROUGHNESS_SMOOTH; 443 } else if (symbolID.equalsIgnoreCase("BOTTOM_SEDIMENTS_LAND")) { 444 return TacticalLines.BOTTOM_SEDIMENTS_LAND; 445 } else if (symbolID.equalsIgnoreCase("BOTTOM_SEDIMENTS_NO_DATA")) { 446 return TacticalLines.BOTTOM_SEDIMENTS_NO_DATA; 447 } else if (symbolID.equalsIgnoreCase("SAND_AND_SHELLS")) { 448 return TacticalLines.SAND_AND_SHELLS; 449 } else if (symbolID.equalsIgnoreCase("PEBBLES")) { 450 return TacticalLines.PEBBLES; 451 } else if (symbolID.equalsIgnoreCase("OYSTER_SHELLS")) { 452 return TacticalLines.OYSTER_SHELLS; 453 } else if (symbolID.equalsIgnoreCase("BOULDERS")) { 454 return TacticalLines.BOULDERS; 455 } else if (symbolID.equalsIgnoreCase("COARSE_SILT")) { 456 return TacticalLines.COARSE_SILT; 457 } else if (symbolID.equalsIgnoreCase("MEDIUM_SILT")) { 458 return TacticalLines.MEDIUM_SILT; 459 } else if (symbolID.equalsIgnoreCase("FINE_SILT")) { 460 return TacticalLines.FINE_SILT; 461 } else if (symbolID.equalsIgnoreCase("VERY_FINE_SILT")) { 462 return TacticalLines.VERY_FINE_SILT; 463 } else if (symbolID.equalsIgnoreCase("VERY_FINE_SAND")) { 464 return TacticalLines.VERY_FINE_SAND; 465 } else if (symbolID.equalsIgnoreCase("FINE_SAND")) { 466 return TacticalLines.FINE_SAND; 467 } else if (symbolID.equalsIgnoreCase("MEDIUM_SAND")) { 468 return TacticalLines.MEDIUM_SAND; 469 } else if (symbolID.equalsIgnoreCase("COARSE_SAND")) { 470 return TacticalLines.COARSE_SAND; 471 } else if (symbolID.equalsIgnoreCase("VERY_COARSE_SAND")) { 472 return TacticalLines.VERY_COARSE_SAND; 473 } else if (symbolID.equalsIgnoreCase("CLAY")) { 474 return TacticalLines.CLAY; 475 } else if (symbolID.equalsIgnoreCase("SOLID_ROCK")) { 476 return TacticalLines.SOLID_ROCK; 477 } else if (symbolID.equalsIgnoreCase("VDR_LEVEL_12")) { 478 return TacticalLines.VDR_LEVEL_12; 479 } else if (symbolID.equalsIgnoreCase("VDR_LEVEL_23")) { 480 return TacticalLines.VDR_LEVEL_23; 481 } else if (symbolID.equalsIgnoreCase("VDR_LEVEL_34")) { 482 return TacticalLines.VDR_LEVEL_34; 483 } else if (symbolID.equalsIgnoreCase("VDR_LEVEL_45")) { 484 return TacticalLines.VDR_LEVEL_45; 485 } else if (symbolID.equalsIgnoreCase("VDR_LEVEL_56")) { 486 return TacticalLines.VDR_LEVEL_56; 487 } else if (symbolID.equalsIgnoreCase("VDR_LEVEL_67")) { 488 return TacticalLines.VDR_LEVEL_67; 489 } else if (symbolID.equalsIgnoreCase("VDR_LEVEL_78")) { 490 return TacticalLines.VDR_LEVEL_78; 491 } else if (symbolID.equalsIgnoreCase("VDR_LEVEL_89")) { 492 return TacticalLines.VDR_LEVEL_89; 493 } else if (symbolID.equalsIgnoreCase("VDR_LEVEL_910")) { 494 return TacticalLines.VDR_LEVEL_910; 495 } else if (symbolID.equalsIgnoreCase("CANAL")) { 496 return TacticalLines.CANAL; 497 } else if (symbolID.equalsIgnoreCase("SUBMERGED_CRIB")) { 498 return TacticalLines.SUBMERGED_CRIB; 499 } else if (symbolID.equalsIgnoreCase("OPERATOR_DEFINED")) { 500 return TacticalLines.OPERATOR_DEFINED; 501 } else if (symbolID.equalsIgnoreCase("MARITIME_AREA")) { 502 return TacticalLines.MARITIME_AREA; 503 } else if (symbolID.equalsIgnoreCase("MARITIME_LIMIT")) { 504 return TacticalLines.MARITIME_LIMIT; 505 } else if (symbolID.equalsIgnoreCase("BEACH_SLOPE_GENTLE")) { 506 return TacticalLines.BEACH_SLOPE_GENTLE; 507 } else if (symbolID.equalsIgnoreCase("BEACH_SLOPE_FLAT")) { 508 return TacticalLines.BEACH_SLOPE_FLAT; 509 } else if (symbolID.equalsIgnoreCase("DISCOLORED_WATER")) { 510 return TacticalLines.DISCOLORED_WATER; 511 } else if (symbolID.equalsIgnoreCase("BREAKERS")) { 512 return TacticalLines.BREAKERS; 513 } else if (symbolID.equalsIgnoreCase("UNDERWATER_HAZARD")) { 514 return TacticalLines.UNDERWATER_HAZARD; 515 } else if (symbolID.equalsIgnoreCase("PERCHES")) { 516 return TacticalLines.PERCHES; 517 } else if (symbolID.equalsIgnoreCase("LOADING_FACILITY_LINE")) { 518 return TacticalLines.LOADING_FACILITY_LINE; 519 } else if (symbolID.equalsIgnoreCase("LOADING_FACILITY_AREA")) { 520 return TacticalLines.LOADING_FACILITY_AREA; 521 } else if (symbolID.equalsIgnoreCase("DRYDOCK")) { 522 return TacticalLines.DRYDOCK; 523 } else if (symbolID.equalsIgnoreCase("FORESHORE_LINE")) { 524 return TacticalLines.FORESHORE_LINE; 525 } else if (symbolID.equalsIgnoreCase("FORESHORE_AREA")) { 526 return TacticalLines.FORESHORE_AREA; 527 } else if (symbolID.equalsIgnoreCase("ICE_DRIFT")) { 528 return TacticalLines.ICE_DRIFT; 529 } else if (symbolID.equalsIgnoreCase("REEF")) { 530 return TacticalLines.REEF; 531 } else if (symbolID.equalsIgnoreCase("RESTRICTED_AREA")) { 532 return TacticalLines.RESTRICTED_AREA; 533 } else if (symbolID.equalsIgnoreCase("TRAINING_AREA")) { 534 return TacticalLines.TRAINING_AREA; 535 } else if (symbolID.equalsIgnoreCase("PIPE")) { 536 return TacticalLines.PIPE; 537 } else if (symbolID.equalsIgnoreCase("ANCHORAGE_LINE")) { 538 return TacticalLines.ANCHORAGE_LINE; 539 } else if (symbolID.equalsIgnoreCase("ANCHORAGE_AREA")) { 540 return TacticalLines.ANCHORAGE_AREA; 541 } else if (symbolID.equalsIgnoreCase("BEACH_SLOPE_STEEP")) { 542 return TacticalLines.BEACH_SLOPE_STEEP; 543 } else if (symbolID.equalsIgnoreCase("BEACH_SLOPE_MODERATE")) { 544 return TacticalLines.BEACH_SLOPE_MODERATE; 545 } else if (symbolID.equalsIgnoreCase("KELP")) { 546 return TacticalLines.KELP; 547 } else if (symbolID.equalsIgnoreCase("FOUL_GROUND")) { 548 return TacticalLines.FOUL_GROUND; 549 } else if (symbolID.equalsIgnoreCase("OIL_RIG_FIELD")) { 550 return TacticalLines.OIL_RIG_FIELD; 551 } else if (symbolID.equalsIgnoreCase("SWEPT_AREA")) { 552 return TacticalLines.SWEPT_AREA; 553 } else if (symbolID.equalsIgnoreCase("WEIRS")) { 554 return TacticalLines.WEIRS; 555 } else if (symbolID.equalsIgnoreCase("BEACH")) { 556 return TacticalLines.BEACH; 557 } else if (symbolID.equalsIgnoreCase("WATER")) { 558 return TacticalLines.WATER; 559 } else if (symbolID.equalsIgnoreCase("ISLAND")) { 560 return TacticalLines.ISLAND; 561 } else if (symbolID.equalsIgnoreCase("DEPTH_AREA")) { 562 return TacticalLines.DEPTH_AREA; 563 } else if (symbolID.equalsIgnoreCase("LRO")) { 564 return TacticalLines.LRO; 565 } else if (symbolID.equalsIgnoreCase("LVO")) { 566 return TacticalLines.LVO; 567 } else if (symbolID.equalsIgnoreCase("UNDERCAST")) { 568 return TacticalLines.UNDERCAST; 569 } else if (symbolID.equalsIgnoreCase("SAND")) { 570 return TacticalLines.SAND; 571 } else if (symbolID.equalsIgnoreCase("OPERATOR_FREEFORM")) { 572 return TacticalLines.OPERATOR_FREEFORM; 573 } else if (symbolID.equalsIgnoreCase("FREEFORM")) { 574 return TacticalLines.FREEFORM; 575 } else if (symbolID.equalsIgnoreCase("FOG")) { 576 return TacticalLines.FOG; 577 } else if (symbolID.equalsIgnoreCase("THUNDERSTORMS")) { 578 return TacticalLines.THUNDERSTORMS; 579 } else if (symbolID.equalsIgnoreCase("FROZEN")) { 580 return TacticalLines.FROZEN; 581 } else if (symbolID.equalsIgnoreCase("ICING")) { 582 return TacticalLines.ICING; 583 } else if (symbolID.equalsIgnoreCase("NON_CONVECTIVE")) { 584 return TacticalLines.NON_CONVECTIVE; 585 } else if (symbolID.equalsIgnoreCase("CONVECTIVE")) { 586 return TacticalLines.CONVECTIVE; 587 } else if (symbolID.equalsIgnoreCase("MVFR")) { 588 return TacticalLines.MVFR; 589 } else if (symbolID.equalsIgnoreCase("TURBULENCE")) { 590 return TacticalLines.TURBULENCE; 591 } else if (symbolID.equalsIgnoreCase("IFR")) { 592 return TacticalLines.IFR; 593 } else if (symbolID.equalsIgnoreCase("ITD")) { 594 return TacticalLines.ITD; 595 } else if (symbolID.equalsIgnoreCase("CONVERGANCE")) { 596 return TacticalLines.CONVERGANCE; 597 } else if (symbolID.equalsIgnoreCase("ITC")) { 598 return TacticalLines.ITC; 599 } else if (symbolID.equalsIgnoreCase("SEVERE")) { 600 return TacticalLines.SQUALL; 601 } else if (symbolID.equalsIgnoreCase("SQUALL")) { 602 return TacticalLines.SQUALL; 603 } else if (symbolID.equalsIgnoreCase("RIDGE")) { 604 return TacticalLines.RIDGE; 605 } else if (symbolID.equalsIgnoreCase("TROUGH")) { 606 return TacticalLines.TROUGH; 607 } else if (symbolID.equalsIgnoreCase("INSTABILITY")) { 608 return TacticalLines.INSTABILITY; 609 } else if (symbolID.equalsIgnoreCase("SHEAR")) { 610 return TacticalLines.SHEAR; 611 } else if (symbolID.equalsIgnoreCase("UCF")) { 612 return TacticalLines.UCF; 613 } else if (symbolID.equalsIgnoreCase("CFG")) { 614 return TacticalLines.CFG; 615 } else if (symbolID.equalsIgnoreCase("CFY")) { 616 return TacticalLines.CFY; 617 } else if (symbolID.equalsIgnoreCase("UWF")) { 618 return TacticalLines.UWF; 619 } else if (symbolID.equalsIgnoreCase("WF")) { 620 return TacticalLines.WF; 621 } else if (symbolID.equalsIgnoreCase("WFG")) { 622 return TacticalLines.WFG; 623 } else if (symbolID.equalsIgnoreCase("WFY")) { 624 return TacticalLines.WFY; 625 } else if (symbolID.equalsIgnoreCase("OCCLUDED")) { 626 return TacticalLines.OCCLUDED; 627 } else if (symbolID.equalsIgnoreCase("UOF")) { 628 return TacticalLines.UOF; 629 } else if (symbolID.equalsIgnoreCase("OFY")) { 630 return TacticalLines.OFY; 631 } else if (symbolID.equalsIgnoreCase("SF")) { 632 return TacticalLines.SF; 633 } else if (symbolID.equalsIgnoreCase("USF")) { 634 return TacticalLines.USF; 635 } else if (symbolID.equalsIgnoreCase("SFG")) { 636 return TacticalLines.SFG; 637 } else if (symbolID.equalsIgnoreCase("SFY")) { 638 return TacticalLines.SFY; 639 } else if (symbolID.equalsIgnoreCase("ISOBAR")) { 640 return TacticalLines.ISOBAR; 641 } else if (symbolID.equalsIgnoreCase("UPPER_AIR")) { 642 return TacticalLines.UPPER_AIR; 643 } else if (symbolID.equalsIgnoreCase("LEADING_LINE")) { 644 return TacticalLines.LEADING_LINE; 645 } else if (symbolID.equalsIgnoreCase("ISODROSOTHERM")) { 646 return TacticalLines.ISODROSOTHERM; 647 } else if (symbolID.equalsIgnoreCase("CRACKS")) { 648 return TacticalLines.CRACKS; 649 } else if (symbolID.equalsIgnoreCase("ICE_EDGE")) { 650 return TacticalLines.ICE_EDGE; 651 } else if (symbolID.equalsIgnoreCase("DEPTH_CURVE")) { 652 return TacticalLines.DEPTH_CURVE; 653 } else if (symbolID.equalsIgnoreCase("DEPTH_CONTOUR")) { 654 return TacticalLines.DEPTH_CONTOUR; 655 } else if (symbolID.equalsIgnoreCase("COASTLINE")) { 656 return TacticalLines.COASTLINE; 657 } else if (symbolID.equalsIgnoreCase("PIER")) { 658 return TacticalLines.PIER; 659 } else if (symbolID.equalsIgnoreCase("RAMP_ABOVE_WATER")) { 660 return TacticalLines.RAMP_ABOVE_WATER; 661 } else if (symbolID.equalsIgnoreCase("JETTY_ABOVE_WATER")) { 662 return TacticalLines.JETTY_ABOVE_WATER; 663 } else if (symbolID.equalsIgnoreCase("SEAWALL")) { 664 return TacticalLines.SEAWALL; 665 } else if (symbolID.equalsIgnoreCase("CABLE")) { 666 return TacticalLines.CABLE; 667 } else if (symbolID.equalsIgnoreCase("ICE_OPENINGS_LEAD")) { 668 return TacticalLines.ICE_OPENINGS_LEAD; 669 } else if (symbolID.equalsIgnoreCase("ISOTACH")) { 670 return TacticalLines.ISOTACH; 671 } else if (symbolID.equalsIgnoreCase("ISOTHERM")) { 672 return TacticalLines.ISOTHERM; 673 } else if (symbolID.equalsIgnoreCase("ISOPLETHS")) { 674 return TacticalLines.ISOPLETHS; 675 } else if (symbolID.equalsIgnoreCase("ESTIMATED_ICE_EDGE")) { 676 return TacticalLines.ESTIMATED_ICE_EDGE; 677 } else if (symbolID.equalsIgnoreCase("RAMP_BELOW_WATER")) { 678 return TacticalLines.RAMP_BELOW_WATER; 679 } else if (symbolID.equalsIgnoreCase("JETTY_BELOW_WATER")) { 680 return TacticalLines.JETTY_BELOW_WATER; 681 } else if (symbolID.equalsIgnoreCase("ICE_OPENINGS_FROZEN")) { 682 return TacticalLines.ICE_OPENINGS_FROZEN; 683 } else if (symbolID.equalsIgnoreCase("ICE_EDGE_RADAR")) { 684 return TacticalLines.ICE_EDGE_RADAR; 685 } else if (symbolID.equalsIgnoreCase("CRACKS_SPECIFIC_LOCATION")) { 686 return TacticalLines.CRACKS_SPECIFIC_LOCATION; 687 } else if (symbolID.equalsIgnoreCase("EBB_TIDE")) { 688 return TacticalLines.EBB_TIDE; 689 } else if (symbolID.equalsIgnoreCase("FLOOD_TIDE")) { 690 return TacticalLines.FLOOD_TIDE; 691 } else if (symbolID.equalsIgnoreCase("JET")) { 692 return TacticalLines.JET; 693 } else if (symbolID.equalsIgnoreCase("STREAM")) { 694 return TacticalLines.STREAM; 695 } 696 697 if (symbolID.length() != 15) { 698 return -1; 699 } 700 701 String strLine = symbolID; 702 String str1, str2, str3, str4, str5, str6, str7, str10; 703 String c0 = strLine.substring(0, 1); 704 String c1 = strLine.substring(1, 2); 705 String c2 = strLine.substring(2, 3); 706 //int bolUseEllipticArc=0; 707 708 str1 = strLine.substring(4, 5);//was(4,1) 709 str2 = strLine.substring(4, 6);//was(4,2) 710 str3 = strLine.substring(4, 7);//was(4,3) 711 str4 = strLine.substring(4, 8);//was(4,4) 712 str5 = strLine.substring(4, 9);//was(4,5) 713 str6 = strLine.substring(3, 9);//was(3,6) 714 str7 = strLine.substring(3, 10);//was(3,7) 715 str10 = strLine.substring(3, 13);//was(3,10) 716 717 //METOC 718 //HOLD 719 if (str3.equals("SLH") && c0.equals("G") && c2.equals("G")) 720 return TacticalLines.HOLD; 721 //BRDGHD 722 if (str3.equals("SLB") && c0.equals("G") && c2.equals("G")) 723 return TacticalLines.BRDGHD; 724 725 if(c0.equalsIgnoreCase("W")==false) 726 return -1; 727 if (c0.equals("W") && c1.equals("A")) { 728 if (str7.equals("DPXSQ--")) { 729 return TacticalLines.SQUALL; 730 } 731 if (str7.equals("DPFC---")) { 732 return TacticalLines.CF; 733 } 734 if (str7.equals("DPFC-FG")) { 735 return TacticalLines.CFG; 736 } 737 if (str7.equals("DPFC-FY")) { 738 return TacticalLines.CFY; 739 } 740 if (str7.equals("DPFW-FG")) { 741 return TacticalLines.WFG; 742 } 743 if (str7.equals("DPFW-FY")) { 744 return TacticalLines.WFY; 745 } 746 if (str7.equals("DPFOU--")) { 747 return TacticalLines.UOF; 748 } 749 if (str7.equals("DPFO-FY")) { 750 return TacticalLines.OFY; 751 } 752 if (str7.equals("DPFSU--")) { 753 return TacticalLines.USF; 754 } 755 if (str7.equals("DPFS-FG")) { 756 return TacticalLines.SFG; 757 } 758 if (str7.equals("DPFS-FY")) { 759 return TacticalLines.SFY; 760 } 761 if (str7.equals("DPXIL--")) { 762 return TacticalLines.INSTABILITY; 763 } 764 if (str7.equals("DPXSH--")) { 765 return TacticalLines.SHEAR; 766 } 767 if (str7.equals("DPXITCZ")) { 768 return TacticalLines.ITC; 769 } 770 if (str7.equals("DPXCV--")) { 771 return TacticalLines.CONVERGANCE; 772 } 773 if (str7.equals("DPXITD-")) { 774 return TacticalLines.ITD; 775 } 776 if (str7.equals("DWJ----")) { 777 return TacticalLines.JET; 778 } 779 if (str7.equals("DWS----")) { 780 return TacticalLines.STREAM; 781 } 782 if (str7.equals("DBAIF--")) { 783 return TacticalLines.IFR; 784 } 785 if (str7.equals("DBAMV--")) { 786 return TacticalLines.MVFR; 787 } 788 if (str7.equals("DBATB--")) { 789 return TacticalLines.TURBULENCE; 790 } 791 if (str7.equals("DBAI---")) { 792 return TacticalLines.ICING; 793 } 794 if (str7.equals("DBALPNC")) { 795 return TacticalLines.NON_CONVECTIVE; 796 } 797 if (str7.equals("DBALPC-")) { 798 return TacticalLines.CONVECTIVE; 799 } 800 if (str7.equals("DBAFP--")) { 801 return TacticalLines.FROZEN; 802 } 803 if (str7.equals("DBAT---")) { 804 return TacticalLines.THUNDERSTORMS; 805 } 806 if (str7.equals("DBAFG--")) { 807 return TacticalLines.FOG; 808 } 809 if (str7.equals("DBAD---")) { 810 return TacticalLines.SAND; 811 } 812 if (str7.equals("DBAFF--")) { 813 return TacticalLines.FREEFORM; 814 } 815 if (str7.equals("DIPIB--")) { 816 return TacticalLines.ISOBAR; 817 } 818 if (str7.equals("DIPCO--")) { 819 return TacticalLines.UPPER_AIR; 820 } 821 if (str7.equals("DIPIS--")) { 822 return TacticalLines.ISOTHERM; 823 } 824 if (str7.equals("DIPIT--")) { 825 return TacticalLines.ISOTACH; 826 } 827 if (str7.equals("DIPID--")) { 828 return TacticalLines.ISODROSOTHERM; 829 } 830 if (str7.equals("DIPTH--")) { 831 return TacticalLines.ISOPLETHS; 832 } 833 if (str7.equals("DIPFF--")) { 834 return TacticalLines.OPERATOR_FREEFORM; 835 } 836 837 838 //if (strncmp(str,"PXR",3).equals(0) 839 if (str3.equals("PXR")) { 840 return TacticalLines.RIDGE; 841 } 842 //if (strncmp(str,"PXS",3).equals(0) 843 //if(str3.equals("PXS") 844 // return TacticalLines.SQUALL; 845 //if (strncmp(str,"PXT",3).equals(0) 846 if (str3.equals("PXT")) { 847 return TacticalLines.TROUGH; 848 } 849 //if (strncmp(str,"PFCU",4).equals(0) 850 if (str4.equals("PFCU")) { 851 return TacticalLines.UCF; 852 } 853 //if (strncmp(str,"PFO",3).equals(0) 854 if (str3.equals("PFO")) { 855 return TacticalLines.OCCLUDED; 856 } 857 //if (strncmp(str,"PFS",3).equals(0) 858 if (str3.equals("PFS")) { 859 return TacticalLines.SF; 860 } 861 //if (strncmp(str,"PFWU",4).equals(0) 862 if (str4.equals("PFWU")) { 863 return TacticalLines.UWF; 864 } 865 //if (strncmp(str,"PFW",3).equals(0) 866 if (str3.equals("PFW")) { 867 return TacticalLines.WF; 868 } 869 //if (strncmp(str,"PFC",3).equals(0) 870 if (str3.equals("PFC")) { 871 return TacticalLines.CF; 872 } 873 } 874 if (c0.equals("W") && c1.equals("O")) { 875 if (str10.equals("DHCF----L-")) { 876 return TacticalLines.FORESHORE_LINE; 877 } 878 if (str10.equals("DHCF-----A")) { 879 return TacticalLines.FORESHORE_AREA; 880 } 881 if (str10.equals("DHPBA---L-")) { 882 return TacticalLines.ANCHORAGE_LINE; 883 } 884 if (str10.equals("DHPBA----A")) { 885 return TacticalLines.ANCHORAGE_AREA; 886 } 887 if (str10.equals("DHPMO---L-")) { 888 return TacticalLines.LOADING_FACILITY_LINE; 889 } 890 if (str10.equals("DHPMO----A")) { 891 return TacticalLines.LOADING_FACILITY_AREA; 892 } 893 } 894 if (c0.equals("W") && c1.equals("O")) { 895 if (str7.equals("DIDID--")) { 896 return TacticalLines.ICE_DRIFT; 897 } 898 if (str7.equals("DILOV--")) { 899 return TacticalLines.LVO; 900 } 901 if (str7.equals("DILUC--")) { 902 return TacticalLines.UNDERCAST; 903 } 904 if (str7.equals("DILOR--")) { 905 return TacticalLines.LRO; 906 } 907 if (str7.equals("DILIEO-")) { 908 return TacticalLines.ICE_EDGE; 909 } 910 if (str7.equals("DILIEE-")) { 911 return TacticalLines.ESTIMATED_ICE_EDGE; 912 } 913 if (str7.equals("DILIER-")) { 914 return TacticalLines.ICE_EDGE_RADAR; 915 } 916 if (str7.equals("DIOC---")) { 917 return TacticalLines.CRACKS; 918 } 919 if (str7.equals("DIOCS--")) { 920 return TacticalLines.CRACKS_SPECIFIC_LOCATION; 921 } 922 if (str7.equals("DIOL---")) { 923 return TacticalLines.ICE_OPENINGS_LEAD; 924 } 925 if (str7.equals("DIOLF--")) { 926 return TacticalLines.ICE_OPENINGS_FROZEN; 927 } 928 if (str7.equals("DHDDL--")) { 929 return TacticalLines.DEPTH_CURVE; 930 } 931 if (str7.equals("DHDDC--")) { 932 return TacticalLines.DEPTH_CONTOUR; 933 } 934 if (str7.equals("DHDDA--")) { 935 return TacticalLines.DEPTH_AREA; 936 } 937 if (str7.equals("DHCC---")) { 938 return TacticalLines.COASTLINE; 939 } 940 if (str7.equals("DHCI---")) { 941 return TacticalLines.ISLAND; 942 } 943 if (str7.equals("DHCB---")) { 944 return TacticalLines.BEACH; 945 } 946 if (str7.equals("DHCW---")) { 947 return TacticalLines.WATER; 948 } 949 if (str7.equals("DHPBP--")) { 950 return TacticalLines.PIER; 951 } 952 if (str7.equals("-HPFF--")) { 953 return TacticalLines.WEIRS; 954 } 955 if (str7.equals("-HHDR--")) { 956 return TacticalLines.REEF; 957 } 958 if (str7.equals("DHPMD--")) { 959 return TacticalLines.DRYDOCK; 960 } 961 if (str7.equals("DHPMRA-")) { 962 return TacticalLines.RAMP_ABOVE_WATER; 963 } 964 if (str7.equals("DHPMRB-")) { 965 return TacticalLines.RAMP_BELOW_WATER; 966 } 967 if (str7.equals("DHPSPA-")) { 968 return TacticalLines.JETTY_ABOVE_WATER; 969 } 970 if (str7.equals("DHPSPB-")) { 971 return TacticalLines.JETTY_BELOW_WATER; 972 } 973 if (str7.equals("DHPSPS-")) { 974 return TacticalLines.SEAWALL; 975 } 976 if (str7.equals("DHABP--")) { 977 return TacticalLines.PERCHES; 978 } 979 if (str7.equals("DHALLA-")) { 980 return TacticalLines.LEADING_LINE; 981 } 982 if (str7.equals("DHHD---")) { 983 return TacticalLines.UNDERWATER_HAZARD; 984 } 985 if (str7.equals("DHHDF--")) { 986 return TacticalLines.FOUL_GROUND; 987 } 988 if (str7.equals("DHHDK--")) { 989 return TacticalLines.KELP; 990 } 991 if (str7.equals("DHHDB--")) { 992 return TacticalLines.BREAKERS; 993 } 994 if (str7.equals("DHHDD--")) { 995 return TacticalLines.DISCOLORED_WATER; 996 } 997 if (str7.equals("DTCCCFE")) { 998 return TacticalLines.EBB_TIDE; 999 } 1000 if (str7.equals("DTCCCFF")) { 1001 return TacticalLines.FLOOD_TIDE; 1002 } 1003 if (str7.equals("DL-RA--")) { 1004 return TacticalLines.RESTRICTED_AREA; 1005 } 1006 if (str7.equals("DMPA---")) { 1007 return TacticalLines.PIPE; 1008 } 1009 if (str7.equals("DL-TA--")) { 1010 return TacticalLines.TRAINING_AREA; 1011 } 1012 if (str7.equals("DOBVA--")) { 1013 return TacticalLines.VDR_LEVEL_12; 1014 } 1015 if (str7.equals("DOBVB--")) { 1016 return TacticalLines.VDR_LEVEL_23; 1017 } 1018 if (str7.equals("DOBVC--")) { 1019 return TacticalLines.VDR_LEVEL_34; 1020 } 1021 if (str7.equals("DOBVD--")) { 1022 return TacticalLines.VDR_LEVEL_45; 1023 } 1024 if (str7.equals("DOBVE--")) { 1025 return TacticalLines.VDR_LEVEL_56; 1026 } 1027 if (str7.equals("DOBVF--")) { 1028 return TacticalLines.VDR_LEVEL_67; 1029 } 1030 if (str7.equals("DOBVG--")) { 1031 return TacticalLines.VDR_LEVEL_78; 1032 } 1033 if (str7.equals("DOBVH--")) { 1034 return TacticalLines.VDR_LEVEL_89; 1035 } 1036 if (str7.equals("DOBVI--")) { 1037 return TacticalLines.VDR_LEVEL_910; 1038 } 1039 if (str7.equals("DBSF---")) { 1040 return TacticalLines.BEACH_SLOPE_FLAT; 1041 } 1042 if (str7.equals("DBSG---")) { 1043 return TacticalLines.BEACH_SLOPE_GENTLE; 1044 } 1045 if (str7.equals("DBSM---")) { 1046 return TacticalLines.BEACH_SLOPE_MODERATE; 1047 } 1048 if (str7.equals("DBST---")) { 1049 return TacticalLines.BEACH_SLOPE_STEEP; 1050 } 1051 if (str7.equals("DGMSR--")) { 1052 return TacticalLines.SOLID_ROCK; 1053 } 1054 if (str7.equals("DGMSC--")) { 1055 return TacticalLines.CLAY; 1056 } 1057 if (str7.equals("DGMSSVS")) { 1058 return TacticalLines.VERY_COARSE_SAND; 1059 } 1060 if (str7.equals("DGMSSC-")) { 1061 return TacticalLines.COARSE_SAND; 1062 } 1063 if (str7.equals("DGMSSM-")) { 1064 return TacticalLines.MEDIUM_SAND; 1065 } 1066 if (str7.equals("DGMSSF-")) { 1067 return TacticalLines.FINE_SAND; 1068 } 1069 if (str7.equals("DGMSSVF")) { 1070 return TacticalLines.VERY_FINE_SAND; 1071 } 1072 if (str7.equals("DGMSIVF")) { 1073 return TacticalLines.VERY_FINE_SILT; 1074 } 1075 if (str7.equals("DGMSIF-")) { 1076 return TacticalLines.FINE_SILT; 1077 } 1078 if (str7.equals("DGMSIM-")) { 1079 return TacticalLines.MEDIUM_SILT; 1080 } 1081 if (str7.equals("DGMSIC-")) { 1082 return TacticalLines.COARSE_SILT; 1083 } 1084 if (str7.equals("DGMSB--")) { 1085 return TacticalLines.BOULDERS; 1086 } 1087 if (str7.equals("DGMS-CO")) { 1088 return TacticalLines.OYSTER_SHELLS; 1089 } 1090 if (str7.equals("DGMS-PH")) { 1091 return TacticalLines.PEBBLES; 1092 } 1093 if (str7.equals("DGMS-SH")) { 1094 return TacticalLines.SAND_AND_SHELLS; 1095 } 1096 if (str7.equals("DGML---")) { 1097 return TacticalLines.BOTTOM_SEDIMENTS_LAND; 1098 } 1099 if (str7.equals("DGMN---")) { 1100 return TacticalLines.BOTTOM_SEDIMENTS_NO_DATA; 1101 } 1102 if (str7.equals("DGMRS--")) { 1103 return TacticalLines.BOTTOM_ROUGHNESS_SMOOTH; 1104 } 1105 if (str7.equals("DGMRM--")) { 1106 return TacticalLines.BOTTOM_ROUGHNESS_MODERATE; 1107 } 1108 if (str7.equals("DGMRR--")) { 1109 return TacticalLines.BOTTOM_ROUGHNESS_ROUGH; 1110 } 1111 if (str7.equals("DGMCL--")) { 1112 return TacticalLines.CLUTTER_LOW; 1113 } 1114 if (str7.equals("DGMCM--")) { 1115 return TacticalLines.CLUTTER_MEDIUM; 1116 } 1117 if (str7.equals("DGMCH--")) { 1118 return TacticalLines.CLUTTER_HIGH; 1119 } 1120 if (str7.equals("DGMIBA-")) { 1121 return TacticalLines.IMPACT_BURIAL_0; 1122 } 1123 if (str7.equals("DGMIBB-")) { 1124 return TacticalLines.IMPACT_BURIAL_10; 1125 } 1126 if (str7.equals("DGMIBC-")) { 1127 return TacticalLines.IMPACT_BURIAL_20; 1128 } 1129 if (str7.equals("DGMIBD-")) { 1130 return TacticalLines.IMPACT_BURIAL_75; 1131 } 1132 if (str7.equals("DGMIBE-")) { 1133 return TacticalLines.IMPACT_BURIAL_100; 1134 } 1135 if (str7.equals("DGMBCA-")) { 1136 return TacticalLines.BOTTOM_CATEGORY_A; 1137 } 1138 if (str7.equals("DGMBCB-")) { 1139 return TacticalLines.BOTTOM_CATEGORY_B; 1140 } 1141 if (str7.equals("DGMBCC-")) { 1142 return TacticalLines.BOTTOM_CATEGORY_C; 1143 } 1144 if (str7.equals("DGMBTA-")) { 1145 return TacticalLines.BOTTOM_TYPE_A1; 1146 } 1147 if (str7.equals("DGMBTB-")) { 1148 return TacticalLines.BOTTOM_TYPE_A2; 1149 } 1150 if (str7.equals("DGMBTC-")) { 1151 return TacticalLines.BOTTOM_TYPE_A3; 1152 } 1153 if (str7.equals("DGMBTD-")) { 1154 return TacticalLines.BOTTOM_TYPE_B1; 1155 } 1156 if (str7.equals("DGMBTE-")) { 1157 return TacticalLines.BOTTOM_TYPE_B2; 1158 } 1159 if (str7.equals("DGMBTF-")) { 1160 return TacticalLines.BOTTOM_TYPE_B3; 1161 } 1162 if (str7.equals("DGMBTG-")) { 1163 return TacticalLines.BOTTOM_TYPE_C1; 1164 } 1165 if (str7.equals("DGMBTH-")) { 1166 return TacticalLines.BOTTOM_TYPE_C2; 1167 } 1168 if (str7.equals("DGMBTI-")) { 1169 return TacticalLines.BOTTOM_TYPE_C3; 1170 } 1171 if (str7.equals("DL-SA--")) { 1172 return TacticalLines.SWEPT_AREA; 1173 } 1174 if (str7.equals("DMOA---")) { 1175 return TacticalLines.OIL_RIG_FIELD; 1176 } 1177 if (str7.equals("DMCC---")) { 1178 return TacticalLines.SUBMERGED_CRIB; 1179 } 1180 if (str7.equals("DMCA---")) { 1181 return TacticalLines.CABLE; 1182 } 1183 if (str7.equals("DL-ML--")) { 1184 return TacticalLines.MARITIME_LIMIT; 1185 } 1186 if (str7.equals("DL-MA--")) { 1187 return TacticalLines.MARITIME_AREA; 1188 } 1189 if (str7.equals("DMCD---")) { 1190 return TacticalLines.CANAL; 1191 } 1192 if (str7.equals("DL-O---")) { 1193 return TacticalLines.OPERATOR_DEFINED; 1194 } 1195 } 1196 } 1197 catch (Exception exc) { 1198 //clsUtility.WriteFile("Error in clsMETOC.IsWeather"); 1199 ErrorLogger.LogException(_className ,"isWeather", 1200 new RendererException("Failed inside isWeather", exc)); 1201 } 1202 //end METOC section 1203 return -1; 1204 } 1205/** 1206 * Sets tactical graphic properties based on Mil-Std-2525 Appendix C. 1207 * @param tg 1208 */ 1209 private static void SetMeTOCProperties(TGLight tg) { 1210 try 1211 { 1212 //METOC's have no user defined fills 1213 //any fills per Mil-Std-2525 will be set below 1214 //tg.set_FillColor(null); 1215 String symbolId=tg.get_SymbolId(); 1216 switch (tg.get_LineType()) { //255:150:150 1217 case TacticalLines.TROUGH: 1218 if(symbolId.length()>=20) 1219 { 1220 String setB=symbolId.substring(10); 1221 String entityCode=setB.substring(0,6); 1222 if(entityCode.equalsIgnoreCase("110401")) 1223 { 1224 tg.set_LineStyle(2); 1225 } 1226 } 1227 tg.set_LineColor(Color.BLACK); 1228 break; 1229 case TacticalLines.BOTTOM_TYPE_A2: 1230 tg.set_LineColor(new Color(127, 255, 0)); //light green 1231 tg.set_FillColor(new Color(127, 255, 0)); 1232 break; 1233 case TacticalLines.BOTTOM_TYPE_C2: 1234 tg.set_LineColor(new Color(255, 80, 0)); //dark orange 1235 tg.set_FillColor(new Color(255, 80, 0)); 1236 break; 1237 case TacticalLines.BOTTOM_TYPE_C3: 1238 tg.set_LineColor(new Color(255, 48, 0)); //orange red 1239 tg.set_FillColor(new Color(255, 48, 0)); 1240 break; 1241 case TacticalLines.IMPACT_BURIAL_0: 1242 tg.set_LineColor(new Color(0, 0, 255)); //blue 1243 tg.set_FillColor(new Color(0, 0, 255)); 1244 break; 1245 case TacticalLines.BOTTOM_TYPE_C1: 1246 case TacticalLines.IMPACT_BURIAL_75: 1247 tg.set_LineColor(new Color(255, 127, 0)); //orange 1248 tg.set_FillColor(new Color(255, 127, 0)); 1249 break; 1250 case TacticalLines.BOTTOM_CATEGORY_C: 1251 case TacticalLines.IMPACT_BURIAL_100: 1252 case TacticalLines.CLUTTER_HIGH: 1253 case TacticalLines.BOTTOM_ROUGHNESS_ROUGH: 1254 tg.set_LineColor(new Color(255, 0, 0)); //red 1255 tg.set_FillColor(new Color(255, 0, 0)); 1256 break; 1257 case TacticalLines.BOTTOM_TYPE_B2: 1258 case TacticalLines.BOTTOM_CATEGORY_B: 1259 case TacticalLines.IMPACT_BURIAL_20: 1260 case TacticalLines.CLUTTER_MEDIUM: 1261 case TacticalLines.BOTTOM_ROUGHNESS_MODERATE: 1262 tg.set_LineColor(new Color(255, 255, 0)); //yellow 1263 tg.set_FillColor(new Color(255, 255, 0)); 1264 break; 1265 case TacticalLines.BOTTOM_TYPE_A1: 1266 case TacticalLines.BOTTOM_CATEGORY_A: 1267 case TacticalLines.IMPACT_BURIAL_10: 1268 case TacticalLines.CLUTTER_LOW: 1269 case TacticalLines.BOTTOM_ROUGHNESS_SMOOTH: 1270 tg.set_LineColor(new Color(0, 255, 0)); //green 1271 tg.set_FillColor(new Color(0, 255, 0)); 1272 break; 1273 case TacticalLines.BOTTOM_SEDIMENTS_NO_DATA: 1274 tg.set_LineColor(new Color(230, 230, 230)); //light gray 1275 tg.set_FillColor(new Color(230, 230, 230)); 1276 break; 1277 case TacticalLines.BOTTOM_SEDIMENTS_LAND: 1278 tg.set_LineColor(new Color(220, 220, 220)); //gray 1279 tg.set_FillColor(new Color(220, 220, 220)); 1280 break; 1281 case TacticalLines.SAND_AND_SHELLS: 1282 tg.set_LineColor(new Color(255, 220, 220)); //light peach 1283 tg.set_FillColor(new Color(255, 220, 220)); 1284 break; 1285 case TacticalLines.PEBBLES: 1286 tg.set_LineColor(new Color(255, 190, 190)); //peach 1287 tg.set_FillColor(new Color(255, 190, 190)); 1288 break; 1289 case TacticalLines.OYSTER_SHELLS: 1290 tg.set_LineColor(new Color(255, 150, 150)); //dark peach 1291 tg.set_FillColor(new Color(255, 150, 150)); 1292 break; 1293 case TacticalLines.BOULDERS: 1294 tg.set_LineColor(new Color(255, 0, 0)); 1295 tg.set_FillColor(new Color(255, 0, 0)); 1296 break; 1297 case TacticalLines.COARSE_SILT: 1298 tg.set_LineColor(new Color(200, 255, 105)); 1299 tg.set_FillColor(new Color(200, 255, 105)); 1300 break; 1301 case TacticalLines.MEDIUM_SILT: 1302 tg.set_LineColor(new Color(0, 255, 0)); //green 1303 tg.set_FillColor(new Color(0, 255, 0)); 1304 break; 1305 case TacticalLines.FINE_SILT: 1306 tg.set_LineColor(new Color(25, 255, 230)); //turquoise 1307 tg.set_FillColor(new Color(25, 255, 230)); 1308 break; 1309 case TacticalLines.VERY_FINE_SILT: 1310 tg.set_LineColor(new Color(0, 215, 255)); //turquoise 1311 tg.set_FillColor(new Color(0, 215, 255)); 1312 break; 1313 case TacticalLines.VERY_FINE_SAND: 1314 tg.set_LineColor(new Color(255, 255, 220)); //pale yellow 1315 tg.set_FillColor(new Color(255, 255, 220)); 1316 break; 1317 case TacticalLines.FINE_SAND: 1318 tg.set_LineColor(new Color(255, 255, 140)); //light yellow 1319 tg.set_FillColor(new Color(255, 255, 140)); 1320 break; 1321 case TacticalLines.MEDIUM_SAND: 1322 tg.set_LineColor(new Color(255, 235, 0)); //yellow 1323 tg.set_FillColor(new Color(255, 235, 0)); 1324 break; 1325 case TacticalLines.COARSE_SAND: 1326 tg.set_LineColor(new Color(255, 215, 0)); //light gold 1327 tg.set_FillColor(new Color(255, 215, 0)); 1328 break; 1329 case TacticalLines.BOTTOM_TYPE_B3: 1330 tg.set_LineColor(new Color(255, 207, 0)); //gold 1331 tg.set_FillColor(new Color(255, 207, 0)); 1332 break; 1333 case TacticalLines.VERY_COARSE_SAND: 1334 tg.set_LineColor(new Color(255, 180, 0)); //gold 1335 tg.set_FillColor(new Color(255, 180, 0)); 1336 break; 1337 case TacticalLines.CLAY: 1338 tg.set_LineColor(new Color(100, 130, 255)); //periwinkle 1339 tg.set_FillColor(new Color(100, 130, 255)); 1340 break; 1341 case TacticalLines.SOLID_ROCK: 1342 //tg.set_LineColor(new Color(160, 32, 240)); //purple 1343 //tg.set_FillColor(new Color(160, 32, 240)); 1344 tg.set_LineColor(new Color(255, 0, 255)); //magenta 1345 tg.set_FillColor(new Color(255, 0, 255)); 1346 break; 1347 case TacticalLines.VDR_LEVEL_12: 1348 tg.set_LineColor(new Color(26, 153, 55)); //dark green 1349 tg.set_FillColor(new Color(26, 153, 55)); 1350 break; 1351 case TacticalLines.VDR_LEVEL_23: 1352 tg.set_LineColor(new Color(26, 204, 77)); //light green 1353 tg.set_FillColor(new Color(26, 204, 77)); 1354 break; 1355 case TacticalLines.BOTTOM_TYPE_A3: 1356 case TacticalLines.VDR_LEVEL_34: 1357 tg.set_LineColor(new Color(128, 255, 51)); //lime green 1358 tg.set_FillColor(new Color(128, 255, 51)); 1359 break; 1360 case TacticalLines.BOTTOM_TYPE_B1: 1361 case TacticalLines.VDR_LEVEL_45: 1362 tg.set_LineColor(new Color(204, 255, 26)); //yellow green 1363 tg.set_FillColor(new Color(204, 255, 26)); 1364 break; 1365 case TacticalLines.VDR_LEVEL_56: 1366 tg.set_LineColor(new Color(255, 255, 0)); //yellow 1367 tg.set_FillColor(new Color(255, 255, 0)); 1368 break; 1369 case TacticalLines.VDR_LEVEL_67: 1370 tg.set_LineColor(new Color(255, 204, 0)); //gold 1371 tg.set_FillColor(new Color(255, 204, 0)); 1372 break; 1373 case TacticalLines.VDR_LEVEL_78: 1374 tg.set_LineColor(new Color(255, 128, 0)); //light orange 1375 tg.set_FillColor(new Color(255, 128, 0)); 1376 break; 1377 case TacticalLines.VDR_LEVEL_89: 1378 tg.set_LineColor(new Color(255, 77, 0)); //dark orange 1379 tg.set_FillColor(new Color(255, 77, 0)); 1380 break; 1381 case TacticalLines.VDR_LEVEL_910: 1382 tg.set_LineColor(Color.RED); 1383 tg.set_FillColor(Color.RED); 1384 break; 1385 case TacticalLines.CANAL: 1386 tg.set_LineColor(Color.BLACK); 1387 tg.set_LineThickness(4); 1388 break; 1389 case TacticalLines.OPERATOR_DEFINED: 1390 tg.set_LineColor(Color.ORANGE); 1391 break; 1392 case TacticalLines.MARITIME_LIMIT: 1393 tg.set_LineColor(Color.MAGENTA); 1394 tg.set_LineStyle(1); 1395 tg.set_LineThickness(1); 1396 break; 1397 case TacticalLines.MARITIME_AREA: 1398 tg.set_LineColor(Color.MAGENTA); 1399 tg.set_LineStyle(1); 1400 break; 1401 case TacticalLines.PERCHES: 1402 case TacticalLines.SUBMERGED_CRIB: 1403 tg.set_LineColor(Color.BLACK); 1404 tg.set_LineStyle(2); 1405 tg.set_FillColor(Color.BLUE); 1406 break; 1407 case TacticalLines.DISCOLORED_WATER: 1408 case TacticalLines.UNDERWATER_HAZARD: 1409 tg.set_LineColor(Color.BLACK); 1410 tg.set_LineStyle(2); 1411 tg.set_FillColor(new Color(0, 191, 255)); //deep sky blue 1412 break; 1413 case TacticalLines.LOADING_FACILITY_AREA: 1414 tg.set_LineColor(new Color(210, 180, 140)); 1415 tg.set_FillColor(new Color(210, 180, 140)); 1416 break; 1417 case TacticalLines.LOADING_FACILITY_LINE: 1418 tg.set_LineColor(Color.GRAY); 1419 tg.set_LineThickness(4); 1420 break; 1421 case TacticalLines.DRYDOCK: 1422 tg.set_LineColor(Color.BLACK); 1423 //tg.set_FillColor(new Color(165, 42, 42)); //brown 1424 tg.set_FillColor(new Color(205, 133, 63)); //brown 1425 tg.set_LineStyle(1); 1426 break; 1427 case TacticalLines.FORESHORE_AREA: 1428 //tg.set_LineColor(new Color(154, 205, 50)); 1429 //tg.set_FillColor(new Color(154, 205, 50)); 1430 tg.set_LineColor(new Color(173, 255, 47)); 1431 tg.set_FillColor(new Color(173, 255, 47)); 1432 break; 1433 case TacticalLines.FORESHORE_LINE: 1434 //tg.set_LineColor(new Color(154, 205, 50)); 1435 tg.set_LineColor(new Color(173, 255, 47)); 1436 break; 1437 case TacticalLines.RESTRICTED_AREA: 1438 case TacticalLines.TRAINING_AREA: 1439 case TacticalLines.ANCHORAGE_LINE: 1440 case TacticalLines.ANCHORAGE_AREA: 1441 tg.set_LineColor(Color.MAGENTA); 1442 //tg.set_LineStyle(1); //dashed 1443 break; 1444 case TacticalLines.PIPE: 1445 tg.set_LineColor(Color.GRAY); //beige 1446 tg.set_FillColor(Color.GRAY); 1447 break; 1448 case TacticalLines.WATER: 1449 tg.set_LineColor(Color.GRAY); //beige 1450 tg.set_FillColor(Color.WHITE); 1451 tg.set_LineStyle(1); 1452 break; 1453 case TacticalLines.WEIRS: 1454 tg.set_LineColor(new Color(245, 245, 220)); //beige 1455 tg.set_LineStyle(1); 1456 tg.set_LineThickness(3); 1457 break; 1458 case TacticalLines.SWEPT_AREA: 1459 case TacticalLines.OIL_RIG_FIELD: 1460 case TacticalLines.FOUL_GROUND: 1461 case TacticalLines.KELP: 1462 case TacticalLines.BEACH_SLOPE_MODERATE: 1463 case TacticalLines.BEACH_SLOPE_STEEP: 1464 case TacticalLines.BEACH: 1465 tg.set_LineColor(new Color(245, 245, 220)); //beige 1466 break; 1467 case TacticalLines.DEPTH_AREA: 1468 tg.set_LineColor(Color.BLUE); 1469 tg.set_FillColor(Color.WHITE); 1470 break; 1471 case TacticalLines.CONVERGANCE: 1472 case TacticalLines.ITC: 1473 tg.set_LineColor(Color.ORANGE); 1474 break; 1475 case TacticalLines.OFY: 1476 case TacticalLines.OCCLUDED: 1477 tg.set_LineColor(new Color(160, 32, 240)); 1478 tg.set_FillColor(new Color(160, 32, 240)); 1479 break; 1480 case TacticalLines.UOF: 1481 tg.set_LineColor(new Color(160, 32, 240)); 1482 break; 1483 case TacticalLines.WFY: 1484 case TacticalLines.WFG: 1485 case TacticalLines.WF: 1486 tg.set_FillColor(Color.RED); 1487 tg.set_LineColor(Color.RED); 1488 break; 1489 case TacticalLines.UWF: 1490 case TacticalLines.IFR: 1491 tg.set_LineColor(Color.RED); 1492 break; 1493 case TacticalLines.CFG: 1494 case TacticalLines.CFY: 1495 case TacticalLines.CF: 1496 tg.set_LineColor(Color.BLUE); 1497 tg.set_FillColor(Color.BLUE); 1498 break; 1499 case TacticalLines.UCF: 1500 case TacticalLines.MVFR: 1501 tg.set_LineColor(Color.BLUE); 1502 break; 1503 case TacticalLines.TURBULENCE: 1504 tg.set_LineColor(Color.BLUE); 1505 tg.set_LineStyle(2); 1506 break; 1507 case TacticalLines.CABLE: 1508 case TacticalLines.CABLE_GE: 1509 tg.set_LineColor(Color.MAGENTA); 1510 break; 1511 case TacticalLines.ISLAND: 1512 //tg.set_LineColor(new Color(165, 42, 42)); //brown 1513 //tg.set_FillColor(new Color(165, 42, 42)); //brown 1514 tg.set_LineColor(new Color(210, 180, 140)); //tan 1515 tg.set_FillColor(new Color(210, 180, 140)); //tam 1516 break; 1517 case TacticalLines.SEAWALL: 1518 case TacticalLines.SEAWALL_GE: 1519 case TacticalLines.FLOOD_TIDE: 1520 case TacticalLines.FLOOD_TIDE_GE: 1521 case TacticalLines.EBB_TIDE: 1522 case TacticalLines.EBB_TIDE_GE: 1523 case TacticalLines.JETTY_ABOVE_WATER: 1524 case TacticalLines.JETTY_ABOVE_WATER_GE: 1525 tg.set_LineColor(Color.GRAY); 1526 break; 1527 case TacticalLines.BEACH_SLOPE_FLAT: 1528 tg.set_LineColor(new Color(211, 211, 211)); 1529 tg.set_FillColor(null); 1530 break; 1531 case TacticalLines.BEACH_SLOPE_GENTLE: 1532 tg.set_LineColor(new Color(111, 111, 111)); 1533 tg.set_FillColor(null); 1534 break; 1535 case TacticalLines.BREAKERS: 1536 tg.set_LineStyle(1); 1537 tg.set_LineColor(Color.GRAY); 1538 tg.set_LineThickness(1); 1539 break; 1540 case TacticalLines.JETTY_BELOW_WATER: 1541 case TacticalLines.JETTY_BELOW_WATER_GE: 1542 tg.set_LineStyle(1); 1543 tg.set_LineColor(Color.GRAY); 1544 break; 1545 case TacticalLines.DEPTH_CURVE: 1546 case TacticalLines.DEPTH_CURVE_GE: 1547 case TacticalLines.DEPTH_CONTOUR: 1548 case TacticalLines.DEPTH_CONTOUR_GE: 1549 case TacticalLines.COASTLINE: 1550 case TacticalLines.COASTLINE_GE: 1551 case TacticalLines.PIER: 1552 case TacticalLines.PIER_GE: 1553 //tg.set_LineStyle(1); 1554 tg.set_LineThickness(1); 1555 tg.set_LineColor(Color.GRAY); 1556 break; 1557 case TacticalLines.FROZEN: 1558 case TacticalLines.JET: 1559 case TacticalLines.JET_GE: 1560 tg.set_LineColor(Color.RED); 1561 break; 1562 case TacticalLines.THUNDERSTORMS: 1563 tg.set_LineColor(Color.RED); 1564 tg.set_LineStyle(3); 1565 break; 1566 case TacticalLines.RAMP_BELOW_WATER: 1567 case TacticalLines.RAMP_BELOW_WATER_GE: 1568 case TacticalLines.ESTIMATED_ICE_EDGE: 1569 case TacticalLines.ESTIMATED_ICE_EDGE_GE: 1570 tg.set_LineStyle(1); 1571 tg.set_LineColor(Color.BLACK); 1572 break; 1573 case TacticalLines.ISODROSOTHERM: 1574 case TacticalLines.ISODROSOTHERM_GE: 1575 tg.set_LineColor(Color.GREEN); 1576 break; 1577 case TacticalLines.LRO: 1578 case TacticalLines.UNDERCAST: 1579 case TacticalLines.LVO: 1580 case TacticalLines.SQUALL: 1581 case TacticalLines.RIDGE: 1582 //case TacticalLines.TROUGH: 1583 case TacticalLines.ICE_OPENINGS_LEAD: 1584 case TacticalLines.ICE_OPENINGS_LEAD_GE: 1585 case TacticalLines.ICE_OPENINGS_FROZEN: 1586 case TacticalLines.ICE_OPENINGS_FROZEN_GE: 1587 case TacticalLines.LEADING_LINE: 1588 case TacticalLines.STREAM: 1589 case TacticalLines.STREAM_GE: 1590 case TacticalLines.CRACKS: 1591 case TacticalLines.CRACKS_GE: 1592 case TacticalLines.CRACKS_SPECIFIC_LOCATION: 1593 case TacticalLines.CRACKS_SPECIFIC_LOCATION_GE: 1594 case TacticalLines.ISOBAR: 1595 case TacticalLines.ISOBAR_GE: 1596 case TacticalLines.UPPER_AIR: 1597 case TacticalLines.UPPER_AIR_GE: 1598 case TacticalLines.ICE_EDGE: 1599 case TacticalLines.ICE_EDGE_GE: 1600 case TacticalLines.ICE_EDGE_RADAR: 1601 case TacticalLines.ICE_EDGE_RADAR_GE: 1602 case TacticalLines.REEF: 1603 case TacticalLines.ICE_DRIFT: 1604 tg.set_LineColor(Color.BLACK); 1605 break; 1606 case TacticalLines.INSTABILITY: 1607 tg.set_LineStyle(4); 1608 tg.set_LineColor(Color.BLACK); 1609 break; 1610 case TacticalLines.SHEAR: 1611 tg.set_LineStyle(3); 1612 tg.set_LineColor(Color.BLACK); 1613 break; 1614 case TacticalLines.ISOPLETHS: 1615 case TacticalLines.ISOPLETHS_GE: 1616 case TacticalLines.ISOTHERM: 1617 case TacticalLines.ISOTHERM_GE: 1618 tg.set_LineStyle(1); 1619 tg.set_LineColor(Color.RED); 1620 break; 1621 case TacticalLines.ISOTACH: 1622 case TacticalLines.ISOTACH_GE: 1623 tg.set_LineStyle(1); 1624 tg.set_LineColor(new Color(160, 32, 240)); 1625 break; 1626 case TacticalLines.SAND: 1627 case TacticalLines.ICING: 1628 tg.set_LineColor(new Color(165, 42, 42)); //brown 1629 break; 1630 case TacticalLines.NON_CONVECTIVE: 1631 tg.set_LineColor(Color.GREEN); 1632 break; 1633 case TacticalLines.CONVECTIVE: 1634 tg.set_LineColor(Color.GREEN); 1635 tg.set_LineStyle(3); 1636 break; 1637 case TacticalLines.FOG: 1638 tg.set_LineColor(Color.YELLOW); 1639 break; 1640 case TacticalLines.RAMP_ABOVE_WATER: 1641 case TacticalLines.RAMP_ABOVE_WATER_GE: 1642 tg.set_LineColor(Color.BLACK); 1643 break; 1644 default: 1645 break; 1646 } 1647 } 1648 catch (Exception exc) { 1649 //clsUtility.WriteFile("Error in clsMETOC.SetMeTOCProperties"); 1650 ErrorLogger.LogException(_className ,"SetMeTOCProperties", 1651 new RendererException("Failed inside SetMeTOCProperties", exc)); 1652 } 1653 } 1654 1655 /** 1656 * 1657 * Finds next closest point with same x position on the splinePoints curve as pt 1658 * walks up the curve and if it does not find a range that straddles x it return null. 1659 * We ultimately will draw a line from pt to the extrapolated point on the splinePoints spline. 1660 * used for ICE_OPENINGS_FROZEN_LEAD 1661 * 1662 * @param splinePoints - the points on the opposite spline 1663 * @param pt - the point in the original curve from which the line will start 1664 * 1665 * @return The extrapolated point on the opposite spline to which the line will be drawn 1666 */ 1667 private static POINT2 ExtrapolatePointFromCurve(ArrayList<POINT2> splinePoints, 1668 POINT2 pt) { 1669 1670 POINT2 pt2 = null; 1671 try { 1672 double dx = 0; //delta x between two points on the curve 1673 double dy = 0; //delta y between two points on the curve 1674 double m = 1; //the slope dy/dx 1675 double y = 0; //the y component of the calculated interpolation point 1676 double x = pt.x; 1677 int j = 0; 1678 //walk up the index to find points which straddle x. 1679 //if we find a pair which straddle x then extrapolate the y avlue from the curve and 1680 //return the point 1681 int n=splinePoints.size(); 1682 //for (j = 0; j < splinePoints.size() - 1; j++) 1683 for (j = 0; j < n - 1; j++) 1684 { 1685 //increment the index to find a greater value 1686 if (splinePoints.get(j).x <= x && splinePoints.get(j + 1).x >= x) { //extrapolate the point y value from the curve and return the point as Point(x,y) 1687 dx = splinePoints.get(j + 1).x - splinePoints.get(j).x; 1688 dy = splinePoints.get(j + 1).y - splinePoints.get(j).y; 1689 m = dy / dx; 1690 y = splinePoints.get(j).y + (x - splinePoints.get(j).x) * m; 1691 pt2 = new POINT2(x, y); 1692 return pt2; 1693 } 1694 if (splinePoints.get(j).x >= x && splinePoints.get(j + 1).x <= x) { //extrapolate the point y value from the curve and return the point as Point(x,y) 1695 dx = splinePoints.get(j + 1).x - splinePoints.get(j).x; 1696 dy = splinePoints.get(j + 1).y - splinePoints.get(j).y; 1697 m = dy / dx; 1698 y = splinePoints.get(j).y + (x - splinePoints.get(j).x) * m; 1699 pt2 = new POINT2(x, y); 1700 return pt2; 1701 } 1702 } 1703 } catch (Exception exc) { 1704 ErrorLogger.LogException(_className ,"ExtrapolatePointFromCurve", 1705 new RendererException("Failed inside ExtrapolatePointfromCurve", exc)); 1706 } 1707 return pt2; 1708 } 1709 /** 1710 * The public interface, main function to return METOC shapes 1711 * @param tg the tactical graphic 1712 * @param shapes the ShapeInfo array 1713 * @param rev the Mil-Standard-2525 revision 1714 */ 1715 public static void GetMeTOCShape(TGLight tg, 1716 ArrayList<Shape2> shapes, 1717 int rev) { 1718 try 1719 { 1720 if(shapes==null) 1721 return; 1722 GeneralPath lineObject = null; 1723 GeneralPath lineObject2 = null; 1724 ArrayList<POINT2> splinePoints = new ArrayList(); 1725 ArrayList<POINT2> splinePoints2 = new ArrayList(); 1726 double d = 0; 1727 int j = 0, k=0, l=0; 1728 Shape2 shape=null; 1729 POINT2 ptLast = tg.Pixels.get(tg.Pixels.size() - 1); 1730 ArrayList<POINT2> twoSplines = null; 1731 ArrayList<POINT2> upperSpline = null; 1732 ArrayList<POINT2> lowerSpline = null; 1733 ArrayList<POINT2> originalPixels = null; 1734 int t=0,u=0,v=0,w=0,tt=0,uu=0,vv=0,ww=0; 1735 1736 ArrayList<POINT2>pixels=null; 1737 originalPixels=null; 1738 ArrayList<P1>partitions=null; 1739 SetMeTOCProperties(tg); 1740 switch (tg.get_LineType()) { 1741 case TacticalLines.SF: 1742 case TacticalLines.USF: 1743 case TacticalLines.SFG: 1744 case TacticalLines.SFY: 1745 case TacticalLines.WFY: 1746 case TacticalLines.WFG: 1747 case TacticalLines.WF: 1748 case TacticalLines.UWF: 1749 case TacticalLines.UCF: 1750 case TacticalLines.CF: 1751 case TacticalLines.CFG: 1752 case TacticalLines.CFY: 1753 case TacticalLines.OCCLUDED: 1754 case TacticalLines.UOF: 1755 case TacticalLines.OFY: 1756 case TacticalLines.TROUGH: 1757 case TacticalLines.INSTABILITY: 1758 case TacticalLines.SHEAR: 1759 case TacticalLines.RIDGE: 1760 case TacticalLines.SQUALL: 1761 case TacticalLines.ITC: 1762 case TacticalLines.CONVERGANCE: 1763 case TacticalLines.ITD: 1764 case TacticalLines.IFR: 1765 case TacticalLines.MVFR: 1766 case TacticalLines.TURBULENCE: 1767 case TacticalLines.ICING: 1768 case TacticalLines.NON_CONVECTIVE: 1769 case TacticalLines.CONVECTIVE: 1770 case TacticalLines.FROZEN: 1771 case TacticalLines.THUNDERSTORMS: 1772 case TacticalLines.FOG: 1773 case TacticalLines.SAND: 1774 case TacticalLines.FREEFORM: 1775 case TacticalLines.OPERATOR_FREEFORM: 1776 case TacticalLines.LVO: 1777 case TacticalLines.UNDERCAST: 1778 case TacticalLines.LRO: 1779 case TacticalLines.DEPTH_AREA: 1780 case TacticalLines.ISLAND: 1781 case TacticalLines.BEACH: 1782 case TacticalLines.WATER: 1783 case TacticalLines.WEIRS: 1784 case TacticalLines.SWEPT_AREA: 1785 case TacticalLines.OIL_RIG_FIELD: 1786 case TacticalLines.FOUL_GROUND: 1787 case TacticalLines.KELP: 1788 case TacticalLines.BEACH_SLOPE_MODERATE: 1789 case TacticalLines.BEACH_SLOPE_STEEP: 1790 case TacticalLines.ANCHORAGE_AREA: 1791 case TacticalLines.ANCHORAGE_LINE: 1792 case TacticalLines.PIPE: 1793 case TacticalLines.TRAINING_AREA: 1794 case TacticalLines.RESTRICTED_AREA: 1795 case TacticalLines.REEF: 1796 case TacticalLines.ICE_DRIFT: 1797 case TacticalLines.FORESHORE_AREA: 1798 case TacticalLines.FORESHORE_LINE: 1799 case TacticalLines.DRYDOCK: 1800 case TacticalLines.LOADING_FACILITY_LINE: 1801 case TacticalLines.LOADING_FACILITY_AREA: 1802 case TacticalLines.PERCHES: 1803 case TacticalLines.UNDERWATER_HAZARD: 1804 case TacticalLines.BREAKERS: 1805 case TacticalLines.DISCOLORED_WATER: 1806 case TacticalLines.BEACH_SLOPE_FLAT: 1807 case TacticalLines.BEACH_SLOPE_GENTLE: 1808 case TacticalLines.MARITIME_LIMIT: 1809 case TacticalLines.MARITIME_AREA: 1810 case TacticalLines.OPERATOR_DEFINED: 1811 case TacticalLines.SUBMERGED_CRIB: 1812 case TacticalLines.CANAL: 1813 case TacticalLines.VDR_LEVEL_12: 1814 case TacticalLines.VDR_LEVEL_23: 1815 case TacticalLines.VDR_LEVEL_34: 1816 case TacticalLines.VDR_LEVEL_45: 1817 case TacticalLines.VDR_LEVEL_56: 1818 case TacticalLines.VDR_LEVEL_67: 1819 case TacticalLines.VDR_LEVEL_78: 1820 case TacticalLines.VDR_LEVEL_89: 1821 case TacticalLines.VDR_LEVEL_910: 1822 case TacticalLines.SOLID_ROCK: 1823 case TacticalLines.CLAY: 1824 case TacticalLines.VERY_COARSE_SAND: 1825 case TacticalLines.COARSE_SAND: 1826 case TacticalLines.MEDIUM_SAND: 1827 case TacticalLines.FINE_SAND: 1828 case TacticalLines.VERY_FINE_SAND: 1829 case TacticalLines.VERY_FINE_SILT: 1830 case TacticalLines.FINE_SILT: 1831 case TacticalLines.MEDIUM_SILT: 1832 case TacticalLines.COARSE_SILT: 1833 case TacticalLines.BOULDERS: 1834 case TacticalLines.OYSTER_SHELLS: 1835 case TacticalLines.PEBBLES: 1836 case TacticalLines.SAND_AND_SHELLS: 1837 case TacticalLines.BOTTOM_SEDIMENTS_LAND: 1838 case TacticalLines.BOTTOM_SEDIMENTS_NO_DATA: 1839 case TacticalLines.BOTTOM_ROUGHNESS_SMOOTH: 1840 case TacticalLines.BOTTOM_ROUGHNESS_MODERATE: 1841 case TacticalLines.BOTTOM_ROUGHNESS_ROUGH: 1842 case TacticalLines.CLUTTER_LOW: 1843 case TacticalLines.CLUTTER_MEDIUM: 1844 case TacticalLines.CLUTTER_HIGH: 1845 case TacticalLines.IMPACT_BURIAL_0: 1846 case TacticalLines.IMPACT_BURIAL_10: 1847 case TacticalLines.IMPACT_BURIAL_20: 1848 case TacticalLines.IMPACT_BURIAL_75: 1849 case TacticalLines.IMPACT_BURIAL_100: 1850 case TacticalLines.BOTTOM_CATEGORY_A: 1851 case TacticalLines.BOTTOM_CATEGORY_B: 1852 case TacticalLines.BOTTOM_CATEGORY_C: 1853 case TacticalLines.BOTTOM_TYPE_A1: 1854 case TacticalLines.BOTTOM_TYPE_A2: 1855 case TacticalLines.BOTTOM_TYPE_A3: 1856 case TacticalLines.BOTTOM_TYPE_B1: 1857 case TacticalLines.BOTTOM_TYPE_B2: 1858 case TacticalLines.BOTTOM_TYPE_B3: 1859 case TacticalLines.BOTTOM_TYPE_C1: 1860 case TacticalLines.BOTTOM_TYPE_C2: 1861 case TacticalLines.BOTTOM_TYPE_C3: 1862 arraysupport.GetLineArray2(tg.get_LineType(), tg.Pixels, shapes,null,rev,null); 1863 break; 1864 case TacticalLines.ISOBAR: 1865 case TacticalLines.ISOBAR_GE: 1866 case TacticalLines.UPPER_AIR: 1867 case TacticalLines.UPPER_AIR_GE: 1868 case TacticalLines.ISOTHERM: 1869 case TacticalLines.ISOTHERM_GE: 1870 case TacticalLines.ISOTACH: 1871 case TacticalLines.ISOTACH_GE: 1872 case TacticalLines.ISODROSOTHERM: 1873 case TacticalLines.ISODROSOTHERM_GE: 1874 case TacticalLines.ISOPLETHS: 1875 case TacticalLines.ISOPLETHS_GE: 1876 case TacticalLines.ICE_EDGE: 1877 case TacticalLines.ICE_EDGE_GE: 1878 case TacticalLines.ESTIMATED_ICE_EDGE: 1879 case TacticalLines.ESTIMATED_ICE_EDGE_GE: 1880 case TacticalLines.CRACKS: 1881 case TacticalLines.CRACKS_GE: 1882 case TacticalLines.DEPTH_CURVE: 1883 case TacticalLines.DEPTH_CURVE_GE: 1884 case TacticalLines.DEPTH_CONTOUR: 1885 case TacticalLines.DEPTH_CONTOUR_GE: 1886 case TacticalLines.COASTLINE: 1887 case TacticalLines.COASTLINE_GE: 1888 case TacticalLines.PIER: 1889 case TacticalLines.PIER_GE: 1890 case TacticalLines.RAMP_ABOVE_WATER: 1891 case TacticalLines.RAMP_ABOVE_WATER_GE: 1892 case TacticalLines.RAMP_BELOW_WATER: 1893 case TacticalLines.RAMP_BELOW_WATER_GE: 1894 case TacticalLines.JETTY_ABOVE_WATER: 1895 case TacticalLines.JETTY_ABOVE_WATER_GE: 1896 case TacticalLines.JETTY_BELOW_WATER: 1897 case TacticalLines.JETTY_BELOW_WATER_GE: 1898 case TacticalLines.SEAWALL: 1899 case TacticalLines.SEAWALL_GE: 1900 case TacticalLines.EBB_TIDE: 1901 case TacticalLines.FLOOD_TIDE: 1902 case TacticalLines.EBB_TIDE_GE: 1903 case TacticalLines.FLOOD_TIDE_GE: 1904 case TacticalLines.CABLE: 1905 case TacticalLines.CABLE_GE: 1906 case TacticalLines.JET: 1907 case TacticalLines.STREAM: 1908 case TacticalLines.JET_GE: 1909 case TacticalLines.STREAM_GE: 1910 lineObject2 = DrawSplines(tg, splinePoints); 1911 lineObject2.lineTo(ptLast.x, ptLast.y); 1912 shape = new Shape2(Shape2.SHAPE_TYPE_POLYLINE); 1913 shape.setShape(lineObject2); 1914 shapes.add(shape); 1915 break; 1916 case TacticalLines.HOLD_GE: 1917 case TacticalLines.BRDGHD_GE: 1918 if(tg.get_FillColor()!=null && tg.get_FillColor().getAlpha()>1) 1919 { 1920 lineObject2 = DrawSplines(tg, splinePoints); 1921 lineObject2.lineTo(ptLast.x, ptLast.y); 1922 shape = new Shape2(Shape2.SHAPE_TYPE_FILL); 1923 shape.setShape(lineObject2); 1924 shapes.add(shape); 1925 splinePoints.clear(); 1926 } 1927 1928 lineObject2 = DrawSplines(tg, splinePoints); 1929 lineObject2.lineTo(ptLast.x, ptLast.y); 1930 shape = new Shape2(Shape2.SHAPE_TYPE_POLYLINE); 1931 shape.setShape(lineObject2); 1932 shapes.add(shape); 1933 SetShapeProperties(tg,shapes,null); 1934 return; 1935 case TacticalLines.HOLD: 1936 case TacticalLines.BRDGHD: 1937 lineObject2 = DrawSplines(tg, splinePoints); 1938 shape = new Shape2(Shape2.SHAPE_TYPE_POLYLINE); 1939 shape.setShape(lineObject2); 1940 shapes.add(shape); 1941 1942 //diagnostic add section 1-3-11 1943 //this section is to add a fill shape using the spline points 1944 //Use tg.Pixels if splinepoints is empty 1945 //fill did not conform very well to the outline 1946 shape=new Shape2(Shape2.SHAPE_TYPE_POLYLINE); 1947 shape.setFillColor(tg.get_FillColor()); 1948 if(tg.get_FillColor() != null && tg.get_FillColor().getAlpha()>1) 1949 { 1950 if(splinePoints != null && splinePoints.size()>0) 1951 { 1952 shape.moveTo(splinePoints.get(0)); 1953 t=splinePoints.size(); 1954 //for(j=1;j<splinePoints.size();j++) 1955 for(j=1;j<t;j++) 1956 shape.lineTo(splinePoints.get(j)); 1957 1958 shape.lineTo(tg.Pixels.get(tg.Pixels.size()-1)); 1959 shapes.add(0,shape); 1960 } 1961 else 1962 { 1963 shape.moveTo(tg.Pixels.get(0)); 1964 u=tg.Pixels.size(); 1965 //for(j=1;j<tg.Pixels.size();j++) 1966 for(j=1;j<u;j++) 1967 shape.lineTo(tg.Pixels.get(j)); 1968 1969 shape.lineTo(tg.Pixels.get(tg.Pixels.size()-1)); 1970 shapes.add(0,shape); 1971 } 1972 } 1973 //end section 1974 break; 1975 case TacticalLines.CRACKS_SPECIFIC_LOCATION: 1976 case TacticalLines.CRACKS_SPECIFIC_LOCATION_GE: 1977 case TacticalLines.ICE_EDGE_RADAR: 1978 case TacticalLines.ICE_EDGE_RADAR_GE: 1979 lineObject2 = DrawSplines(tg, splinePoints); 1980 shape = new Shape2(Shape2.SHAPE_TYPE_POLYLINE); 1981 shape.setShape(lineObject2); 1982 shapes.add(shape); 1983 break; 1984 case TacticalLines.ICE_OPENINGS_LEAD: 1985 originalPixels=tg.Pixels; 1986 partitions=clsChannelUtility.GetPartitions2(tg); 1987 v=partitions.size(); 1988 //for(l=0;l<partitions.size();l++) 1989 for(l=0;l<v;l++) 1990 { 1991 tg.Pixels=originalPixels; 1992 pixels=new ArrayList(); 1993 for(k=partitions.get(l).start;k<=partitions.get(l).end_Renamed+1;k++) 1994 pixels.add(tg.Pixels.get(k)); 1995 1996 if(pixels==null || pixels.isEmpty()) 1997 continue; 1998 1999 twoSplines = new ArrayList(); 2000 twoSplines = ParallelLines2(pixels,rev); 2001 2002 upperSpline = new ArrayList(); 2003 lowerSpline = new ArrayList(); 2004 w=twoSplines.size(); 2005 //for (j = 0; j < twoSplines.size() / 2; j++) 2006 for (j = 0; j < w / 2; j++) 2007 { 2008 upperSpline.add(twoSplines.get(j)); 2009 } 2010 2011 //for (j = twoSplines.size() / 2; j < twoSplines.size(); j++) 2012 for (j = w / 2; j < w; j++) 2013 { 2014 lowerSpline.add(twoSplines.get(j)); 2015 } 2016 2017 tg.Pixels = lowerSpline; 2018 lineObject2 = DrawSplines(tg, splinePoints); 2019 shape = new Shape2(Shape2.SHAPE_TYPE_POLYLINE); 2020 shape.setShape(lineObject2); 2021 shapes.add(shape); 2022 2023 tg.Pixels = upperSpline; 2024 lineObject2 = DrawSplines(tg, splinePoints); 2025 shape = new Shape2(Shape2.SHAPE_TYPE_POLYLINE); 2026 shape.setShape(lineObject2); 2027 shapes.add(shape); 2028 } 2029 break; 2030 case TacticalLines.ICE_OPENINGS_LEAD_GE: 2031 originalPixels=tg.Pixels; 2032 partitions=clsChannelUtility.GetPartitions2(tg); 2033 t=partitions.size(); 2034 //for(l=0;l<partitions.size();l++) 2035 for(l=0;l<t;l++) 2036 { 2037 tg.Pixels=originalPixels; 2038 pixels=new ArrayList(); 2039 for(k=partitions.get(l).start;k<=partitions.get(l).end_Renamed+1;k++) 2040 pixels.add(tg.Pixels.get(k)); 2041 2042 if(pixels==null || pixels.isEmpty()) 2043 continue; 2044 2045 twoSplines = new ArrayList(); 2046 twoSplines = ParallelLines2(pixels,rev); 2047 2048 upperSpline = new ArrayList(); 2049 lowerSpline = new ArrayList(); 2050 u=twoSplines.size(); 2051 //for (j = 0; j < twoSplines.size() / 2; j++) 2052 for (j = 0; j < u / 2; j++) 2053 { 2054 upperSpline.add(twoSplines.get(j)); 2055 } 2056 2057 //for (j = twoSplines.size() / 2; j < twoSplines.size(); j++) 2058 for (j = u / 2; j < u; j++) 2059 { 2060 lowerSpline.add(twoSplines.get(j)); 2061 } 2062 2063 tg.Pixels = lowerSpline; 2064 lineObject2 = DrawSplines(tg, splinePoints); 2065 ptLast=tg.Pixels.get(tg.Pixels.size()-1); 2066 lineObject2.lineTo(ptLast.x, ptLast.y); 2067 shape = new Shape2(Shape2.SHAPE_TYPE_POLYLINE); 2068 shape.setShape(lineObject2); 2069 shapes.add(shape); 2070 2071 tg.Pixels = upperSpline; 2072 splinePoints=new ArrayList(); 2073 lineObject2 = DrawSplines(tg, splinePoints); 2074 ptLast=tg.Pixels.get(tg.Pixels.size()-1); 2075 lineObject2.lineTo(ptLast.x, ptLast.y); 2076 shape = new Shape2(Shape2.SHAPE_TYPE_POLYLINE); 2077 shape.setShape(lineObject2); 2078 shapes.add(shape); 2079 } 2080 break; 2081 case TacticalLines.ICE_OPENINGS_FROZEN: 2082 originalPixels=tg.Pixels; 2083 partitions=clsChannelUtility.GetPartitions2(tg); 2084 t=partitions.size(); 2085 //for(l=0;l<partitions.size();l++) 2086 for(l=0;l<t;l++) 2087 { 2088 tg.Pixels=originalPixels; 2089 pixels=new ArrayList(); 2090 for(k=partitions.get(l).start;k<=partitions.get(l).end_Renamed+1;k++) 2091 pixels.add(tg.Pixels.get(k)); 2092 2093 if(pixels==null || pixels.isEmpty()) 2094 continue; 2095 2096 twoSplines = new ArrayList(); 2097 //twoSplines = ParallelLines(tg); 2098 twoSplines = ParallelLines2(pixels,rev); 2099 upperSpline = new ArrayList(); 2100 lowerSpline = new ArrayList(); 2101 u=twoSplines.size(); 2102 //for (j = 0; j < twoSplines.size() / 2; j++) 2103 for (j = 0; j < u / 2; j++) 2104 { 2105 upperSpline.add(twoSplines.get(j)); 2106 } 2107 2108 //for (j = twoSplines.size() / 2; j < twoSplines.size(); j++) 2109 for (j = u / 2; j < u; j++) 2110 { 2111 lowerSpline.add(twoSplines.get(j)); 2112 } 2113 2114 tg.Pixels = lowerSpline; 2115 lineObject2 = DrawSplines(tg, splinePoints); 2116 shape = new Shape2(Shape2.SHAPE_TYPE_POLYLINE); 2117 shape.setShape(lineObject2); 2118 shapes.add(shape); 2119 2120 tg.Pixels = upperSpline; 2121 lineObject2 = DrawSplines(tg, splinePoints2); 2122 shape = new Shape2(Shape2.SHAPE_TYPE_POLYLINE); 2123 shape.setShape(lineObject2); 2124 shapes.add(shape); 2125 2126 //parse upper and lower arrys to find the corresponding splines 2127 ArrayList splinePointsArrays = new ArrayList(); 2128 ArrayList splinePoints2Arrays = new ArrayList(); 2129 ArrayList<POINT2> ptsArray = new ArrayList(); 2130 v=splinePoints.size(); 2131 //for (j = 0; j < splinePoints.size(); j++) 2132 for (j = 0; j < v; j++) 2133 { 2134 if (splinePoints.get(j).style != 47) 2135 { 2136 ptsArray.add(splinePoints.get(j)); 2137 } 2138 else 2139 { 2140 splinePointsArrays.add(ptsArray); 2141 ptsArray = new ArrayList(); 2142 } 2143 } 2144 w=splinePoints2.size(); 2145 //for (j = 0; j < splinePoints2.size(); j++) 2146 for (j = 0; j < w; j++) 2147 { 2148 if (splinePoints2.get(j).style != 47) 2149 { 2150 ptsArray.add(splinePoints2.get(j)); 2151 } 2152 else 2153 { 2154 splinePoints2Arrays.add(ptsArray); 2155 ptsArray = new ArrayList(); 2156 } 2157 } 2158 2159 ArrayList<POINT2> array = null; 2160 ArrayList<POINT2> array2 = null; 2161 POINT2 pt, 2162 pt2; 2163 lineObject = new GeneralPath(); 2164 //the lines to connect the extrapolated points 2165 w=splinePointsArrays.size(); 2166 //for (j = 0; j < splinePointsArrays.size(); j++) 2167 for (j = 0; j < w; j++) 2168 { 2169 array = (ArrayList<POINT2>) splinePointsArrays.get(j); 2170 if(splinePoints2Arrays.size()>j) 2171 array2 = (ArrayList<POINT2>) splinePoints2Arrays.get(j); 2172 else 2173 break; 2174 //extrapolate against points in the shortest array 2175 if (splinePointsArrays.size() >= splinePoints2Arrays.size()) //array is shorter 2176 { 2177 tt=array.size(); 2178 //for (k = 0; k < array.size(); k++) 2179 for (k = 0; k < tt; k++) 2180 { 2181 if(array.size()>k) 2182 pt = array.get(k); 2183 else 2184 break; 2185 2186 pt2 = ExtrapolatePointFromCurve(array2, pt); 2187 //if we got a valid extrapolation point then draw the line 2188 if (pt2 != null) { 2189 lineObject.moveTo(pt.x, pt.y); 2190 lineObject.lineTo(pt2.x, pt2.y); 2191 } 2192 } 2193 } else //array2 is shorter 2194 { 2195 uu=array2.size(); 2196 //for (k = 0; k < array2.size(); k++) 2197 for (k = 0; k < uu; k++) 2198 { 2199 pt = array2.get(k); 2200 pt2 = ExtrapolatePointFromCurve(array, pt); 2201 //if we got a valid extrapolation point then draw the line 2202 if (pt2 != null) { 2203 lineObject.moveTo(pt.x, pt.y); 2204 lineObject.lineTo(pt2.x, pt2.y); 2205 } 2206 } 2207 } 2208 } 2209 shape = new Shape2(Shape2.SHAPE_TYPE_POLYLINE); 2210 shape.setShape(lineObject); 2211 shapes.add(shape); 2212 } 2213 //the lines connecting the extrapolated points 2214 break; 2215 case TacticalLines.ICE_OPENINGS_FROZEN_GE: 2216 originalPixels=tg.Pixels; 2217 partitions=clsChannelUtility.GetPartitions2(tg); 2218 t=partitions.size(); 2219 //for(l=0;l<partitions.size();l++) 2220 for(l=0;l<t;l++) 2221 { 2222 tg.Pixels=originalPixels; 2223 pixels=new ArrayList(); 2224 for(k=partitions.get(l).start;k<=partitions.get(l).end_Renamed+1;k++) 2225 pixels.add(tg.Pixels.get(k)); 2226 2227 if(pixels==null || pixels.isEmpty()) 2228 continue; 2229 2230 twoSplines = new ArrayList(); 2231 twoSplines = ParallelLines2(pixels,rev); 2232 upperSpline = new ArrayList(); 2233 lowerSpline = new ArrayList(); 2234 u=twoSplines.size(); 2235 //for (j = 0; j < twoSplines.size() / 2; j++) 2236 for (j = 0; j < u / 2; j++) 2237 { 2238 upperSpline.add(twoSplines.get(j)); 2239 } 2240 2241 //for (j = twoSplines.size() / 2; j < twoSplines.size(); j++) 2242 for (j = u / 2; j < u; j++) 2243 { 2244 lowerSpline.add(twoSplines.get(j)); 2245 } 2246 2247 tg.Pixels = lowerSpline; 2248 ArrayList<POINT2>splinePoints3=new ArrayList(); 2249 lineObject2 = DrawSplines(tg, splinePoints3); 2250 splinePoints.addAll(splinePoints3); 2251 ptLast=tg.Pixels.get(tg.Pixels.size()-1); 2252 lineObject2.lineTo(ptLast.x, ptLast.y); 2253 shape = new Shape2(Shape2.SHAPE_TYPE_POLYLINE); 2254 shape.setShape(lineObject2); 2255 shapes.add(shape); 2256 2257 tg.Pixels = upperSpline; 2258 ArrayList<POINT2>splinePoints4=new ArrayList(); 2259 lineObject2 = DrawSplines(tg, splinePoints4); 2260 splinePoints2.addAll(splinePoints4); 2261 ptLast=tg.Pixels.get(tg.Pixels.size()-1); 2262 lineObject2.lineTo(ptLast.x, ptLast.y); 2263 shape = new Shape2(Shape2.SHAPE_TYPE_POLYLINE); 2264 shape.setShape(lineObject2); 2265 shapes.add(shape); 2266 2267 //parse upper and lower arrys to find the corresponding splines 2268 ArrayList splinePointsArrays = new ArrayList(); 2269 ArrayList splinePoints2Arrays = new ArrayList(); 2270 ArrayList<POINT2> ptsArray = new ArrayList(); 2271 v=splinePoints.size(); 2272 //for (j = 0; j < splinePoints.size(); j++) 2273 for (j = 0; j < v; j++) 2274 { 2275 if (splinePoints.get(j).style != 47) 2276 { 2277 ptsArray.add(splinePoints.get(j)); 2278 } 2279 else 2280 { 2281 splinePointsArrays.add(ptsArray); 2282 ptsArray = new ArrayList(); 2283 } 2284 } 2285 w=splinePoints2.size(); 2286 //for (j = 0; j < splinePoints2.size(); j++) 2287 for (j = 0; j < w; j++) 2288 { 2289 if (splinePoints2.get(j).style != 47) 2290 { 2291 ptsArray.add(splinePoints2.get(j)); 2292 } 2293 else 2294 { 2295 splinePoints2Arrays.add(ptsArray); 2296 ptsArray = new ArrayList(); 2297 } 2298 } 2299 2300 //int k = 0; 2301 ArrayList<POINT2> array = null; 2302 ArrayList<POINT2> array2 = null; 2303 POINT2 pt, 2304 pt2; 2305 lineObject = new GeneralPath(); 2306 //the lines to connect the extrapolated points 2307 tt=splinePointsArrays.size(); 2308 //for (j = 0; j < splinePointsArrays.size(); j++) 2309 for (j = 0; j < tt; j++) 2310 { 2311 array = (ArrayList<POINT2>) splinePointsArrays.get(j); 2312 2313 if(splinePoints2Arrays.size()>j) 2314 array2 = (ArrayList<POINT2>) splinePoints2Arrays.get(j); 2315 else 2316 break; 2317 //extrapolate against points in the shortest array 2318 if (splinePointsArrays.size() >= splinePoints2Arrays.size()) //array is shorter 2319 { 2320 uu=array.size(); 2321 //for (k = 0; k < array.size(); k++) 2322 for (k = 0; k < uu; k++) 2323 { 2324 if(array.size()>k) 2325 pt = array.get(k); 2326 else 2327 break; 2328 2329 pt2 = ExtrapolatePointFromCurve(array2, pt); 2330 //if we got a valid extrapolation point then draw the line 2331 if (pt2 != null) { 2332 lineObject.moveTo(pt.x, pt.y); 2333 lineObject.lineTo(pt2.x, pt2.y); 2334 } 2335 } 2336 } else //array2 is shorter 2337 { 2338 vv=array2.size(); 2339 //for (k = 0; k < array2.size(); k++) 2340 for (k = 0; k < vv; k++) 2341 { 2342 pt = array2.get(k); 2343 pt2 = ExtrapolatePointFromCurve(array, pt); 2344 //if we got a valid extrapolation point then draw the line 2345 if (pt2 != null) { 2346 //sprite2.graphics.moveTo(pt.x,pt.y); 2347 //sprite2.graphics.lineTo(pt2.x,pt2.y); 2348 lineObject.moveTo(pt.x, pt.y); 2349 lineObject.lineTo(pt2.x, pt2.y); 2350 } 2351 } 2352 } 2353 } 2354 shape = new Shape2(Shape2.SHAPE_TYPE_POLYLINE); 2355 shape.setShape(lineObject); 2356 shapes.add(shape); 2357 } 2358 //the lines connecting the extrapolated points 2359 break; 2360 case TacticalLines.LEADING_LINE: 2361 //the solid line 2362 lineObject = DrawSplines(tg, splinePoints); 2363 lineObject2 = new GeneralPath(); 2364 if(splinePoints.size()>0) 2365 lineObject2.moveTo(splinePoints.get(0).x, splinePoints.get(0).y); 2366 else 2367 { 2368 lineObject2.moveTo(tg.Pixels.get(0).x,tg.Pixels.get(0).y); 2369 t=tg.Pixels.size(); 2370 //for(j=0;j<tg.Pixels.size();j++) 2371 for(j=0;j<t;j++) 2372 lineObject2.lineTo(tg.Pixels.get(j).x,tg.Pixels.get(j).y); 2373 2374 shape = new Shape2(Shape2.SHAPE_TYPE_POLYLINE); 2375 shape.setShape(lineObject2); 2376 shape.set_Style(1); 2377 shapes.add(shape); 2378 return; 2379 } 2380 2381 int n = splinePoints.size() / 2; 2382 for (j = 1; j <= n; j++) { 2383 if(splinePoints.size()>=j-1) 2384 lineObject2.lineTo(splinePoints.get(j).x, splinePoints.get(j).y); 2385 } 2386 shape = new Shape2(Shape2.SHAPE_TYPE_POLYLINE); 2387 shape.setShape(lineObject2); 2388 shapes.add(shape); 2389 2390 //the dashed line 2391 lineObject2 = new GeneralPath(); 2392 lineObject2.moveTo(splinePoints.get(n).x, splinePoints.get(n).y); 2393 u=splinePoints.size(); 2394 //for (j = n + 1; j < splinePoints.size(); j++) 2395 for (j = n + 1; j < u; j++) 2396 { 2397 if(splinePoints.size()>=j-1) 2398 lineObject2.lineTo(splinePoints.get(j).x, splinePoints.get(j).y); 2399 } 2400 shape = new Shape2(Shape2.SHAPE_TYPE_POLYLINE); 2401 shape.setShape(lineObject2); 2402 shape.set_Style(1); 2403 shapes.add(shape); 2404 break; 2405 default: 2406 break; 2407 } 2408 //add the last point 2409 if (tg.get_LineType() != TacticalLines.ICE_OPENINGS_LEAD && 2410 tg.get_LineType() != TacticalLines.ICE_OPENINGS_LEAD_GE && 2411 tg.get_LineType() != TacticalLines.ICE_OPENINGS_FROZEN && 2412 tg.get_LineType() != TacticalLines.ICE_OPENINGS_FROZEN_GE && 2413 tg.get_LineType() != TacticalLines.ICE_EDGE_RADAR) 2414 { 2415 if (splinePoints != null && splinePoints.size() > 0) 2416 { 2417 lineObject2 = new GeneralPath(); 2418 lineObject2.moveTo(splinePoints.get(splinePoints.size() - 1).x, splinePoints.get(splinePoints.size() - 1).y); 2419 lineObject2.lineTo(ptLast.x, ptLast.y); 2420 shape = new Shape2(Shape2.SHAPE_TYPE_POLYLINE); 2421 shape.setShape(lineObject2); 2422 shape.set_Style(0); 2423 shapes.add(shape); 2424 } 2425 } 2426 SetShapeProperties(tg, shapes, null); 2427 } 2428 catch (Exception exc) { 2429 ErrorLogger.LogException(_className ,"GetMeTOCShape", 2430 new RendererException("Failed inside GetMeTOCShape", exc)); 2431 } 2432 } 2433/** 2434 * Returns the image file name based on the linetype for the METOC symbols with pattern ill 2435 * @param tg 2436 * @return 2437 */ 2438 private static String GetImageFile(TGLight tg) { 2439 String fileName = ""; 2440 try 2441 { 2442 switch (tg.get_LineType()) { 2443 case TacticalLines.WEIRS: 2444 fileName = "visualAssets/Weirs.png"; 2445 break; 2446 case TacticalLines.SWEPT_AREA: 2447 fileName = "visualAssets/SweptArea.png"; 2448 break; 2449 case TacticalLines.OIL_RIG_FIELD: 2450 fileName = "visualAssets/OilRigField.png"; 2451 break; 2452 case TacticalLines.FOUL_GROUND: 2453 fileName = "visualAssets/FoulGround.png"; 2454 break; 2455 case TacticalLines.KELP: 2456 fileName = "visualAssets/Kelp.png"; 2457 break; 2458 case TacticalLines.BEACH_SLOPE_STEEP: 2459 fileName = "visualAssets/BeachSlopeSteep.png"; 2460 break; 2461 case TacticalLines.BEACH: 2462 fileName = "visualAssets/BeigeStipple.png"; 2463 break; 2464 case TacticalLines.BEACH_SLOPE_MODERATE: 2465 fileName = "visualAssets/BeachSlopeModerate.png"; 2466 break; 2467 default: 2468 break; 2469 } 2470 } 2471 catch(Exception exc) 2472 { 2473 ErrorLogger.LogException(_className ,"GetImageFile", 2474 new RendererException("Failed inside GetImageFile", exc)); 2475 } 2476 2477 return fileName; 2478 } 2479/** 2480 * Sets the shape properties based on the tacttical graphic properties and also based on shape 2481 * styles which may have been set by JavaLineArray 2482 * @param tg 2483 * @param shapes shapes array to set properties 2484 * @param bi BufferedImage used for hatch fills 2485 */ 2486 protected static void SetShapeProperties(TGLight tg, ArrayList<Shape2> shapes, BufferedImage bi) { 2487 try 2488 { 2489 if (shapes == null) 2490 { 2491 return; 2492 } 2493 switch(tg.get_LineType()) 2494 { 2495 case TacticalLines.DEPTH_AREA: 2496 return; 2497 default: 2498 break; 2499 } 2500 2501 int j = 0, n=0; 2502 Shape2 shape = null; 2503 BasicStroke stroke = null; 2504 InputStream inFile = null; 2505 BufferedImage bi2 = null; 2506 float[] dash = null; 2507 int lineThickness = tg.get_LineThickness(); 2508 Rectangle2D.Double rect = null; 2509 Graphics2D grid = null; 2510 TexturePaint tp = tg.get_TexturePaint(); 2511 String fileName = GetImageFile(tg); 2512 switch (tg.get_LineType()) { 2513 case TacticalLines.WEIRS: 2514 case TacticalLines.SWEPT_AREA: 2515 case TacticalLines.OIL_RIG_FIELD: 2516 case TacticalLines.FOUL_GROUND: 2517 case TacticalLines.KELP: 2518 case TacticalLines.BEACH_SLOPE_MODERATE: 2519 case TacticalLines.BEACH_SLOPE_STEEP: 2520 case TacticalLines.BEACH: 2521 //Android does not actually use this, i.e. infile will be null 2522 //the code was retained as part of the port from Java. 2523 //the fills will be created at the end of render_ge 2524 //if(tg.get_UsePatternFill()) 2525 // break; 2526 shape = shapes.get(0); 2527 shape.setLineColor(tg.get_LineColor()); 2528 inFile = clsMETOC.class.getClassLoader().getResourceAsStream(fileName); 2529 if(inFile!=null) 2530 { 2531 bi2 = ImageIO.read(inFile); 2532 rect = new Rectangle2D.Double(0, 0, bi2.getWidth(), bi2.getHeight()); 2533 tp = new TexturePaint(bi2, rect); 2534 shape.setTexturePaint(tp); 2535 inFile.close(); 2536 } 2537 break; 2538 case TacticalLines.SF: 2539 case TacticalLines.USF: 2540 case TacticalLines.SFG: 2541 case TacticalLines.SFY: 2542 n=shapes.size(); 2543 //for (j = 0; j < shapes.size(); j++) 2544 for (j = 0; j < n; j++) 2545 { 2546 shape = shapes.get(j); 2547 if (shape == null || shape.getShape() == null) { 2548 continue; 2549 } 2550 2551 shape.set_Style(tg.get_LineStyle()); 2552 stroke = new BasicStroke(lineThickness, BasicStroke.CAP_ROUND, BasicStroke.JOIN_ROUND, 1, dash, 0); 2553 shape.setStroke(stroke); 2554 } 2555 return; 2556 default: 2557 break; 2558 } 2559 2560 int shapeType = -1; 2561 int lineType = tg.get_LineType(); 2562 boolean isChange1Area = clsUtility.IsChange1Area(lineType, null); 2563 boolean isClosedPolygon = clsUtility.isClosedPolygon(lineType); 2564 n=shapes.size(); 2565 //for (j = 0; j < shapes.size(); j++) 2566 for (j = 0; j < n; j++) 2567 { 2568 shape = shapes.get(j); 2569 if (shape == null || shape.getShape() == null) { 2570 continue; 2571 } 2572 2573 if (shape.getShapeType() == Shape2.SHAPE_TYPE_FILL) { 2574 shape.setFillColor(tg.get_FillColor()); 2575 } 2576 2577 //clsUtility.ResolveModifierShape(tg,shape); 2578 2579 shapeType = shape.getShapeType(); 2580 switch (tg.get_LineType()) { 2581 case TacticalLines.SF: 2582 case TacticalLines.USF: 2583 case TacticalLines.SFG: 2584 case TacticalLines.SFY: 2585 case TacticalLines.ITD: 2586 break; 2587 case TacticalLines.LEADING_LINE: 2588 case TacticalLines.TRAINING_AREA: 2589 shape.setLineColor(tg.get_LineColor()); 2590 break; 2591 case TacticalLines.BRDGHD_GE: 2592 case TacticalLines.HOLD_GE: 2593 if(shape.getShapeType()==ShapeInfo.SHAPE_TYPE_FILL) 2594 shape.setLineColor(null); 2595 else 2596 { 2597 shape.setLineColor(tg.get_LineColor()); 2598 shape.set_Style(tg.get_LineStyle()); 2599 } 2600 break; 2601 default: 2602 shape.setLineColor(tg.get_LineColor()); 2603 shape.set_Style(tg.get_LineStyle()); 2604 break; 2605 } 2606 2607 if (isClosedPolygon || shapeType == Shape2.SHAPE_TYPE_FILL) 2608 { 2609 switch(tg.get_LineType())//these have fill instead of TexturePaint 2610 { 2611 case TacticalLines.FORESHORE_AREA: 2612 case TacticalLines.WATER: 2613 case TacticalLines.ISLAND: 2614 case TacticalLines.DRYDOCK: 2615 case TacticalLines.LOADING_FACILITY_AREA: 2616 case TacticalLines.PERCHES: 2617 case TacticalLines.UNDERWATER_HAZARD: 2618 case TacticalLines.DISCOLORED_WATER: 2619 case TacticalLines.VDR_LEVEL_12: 2620 case TacticalLines.VDR_LEVEL_23: 2621 case TacticalLines.VDR_LEVEL_34: 2622 case TacticalLines.VDR_LEVEL_45: 2623 case TacticalLines.VDR_LEVEL_56: 2624 case TacticalLines.VDR_LEVEL_67: 2625 case TacticalLines.VDR_LEVEL_78: 2626 case TacticalLines.VDR_LEVEL_89: 2627 case TacticalLines.VDR_LEVEL_910: 2628 case TacticalLines.SOLID_ROCK: 2629 case TacticalLines.CLAY: 2630 case TacticalLines.FINE_SAND: 2631 case TacticalLines.MEDIUM_SAND: 2632 case TacticalLines.COARSE_SAND: 2633 case TacticalLines.VERY_COARSE_SAND: 2634 case TacticalLines.VERY_FINE_SAND: 2635 case TacticalLines.VERY_FINE_SILT: 2636 case TacticalLines.FINE_SILT: 2637 case TacticalLines.MEDIUM_SILT: 2638 case TacticalLines.COARSE_SILT: 2639 case TacticalLines.BOULDERS: 2640 case TacticalLines.OYSTER_SHELLS: 2641 case TacticalLines.PEBBLES: 2642 case TacticalLines.SAND_AND_SHELLS: 2643 case TacticalLines.BOTTOM_SEDIMENTS_LAND: 2644 case TacticalLines.BOTTOM_SEDIMENTS_NO_DATA: 2645 case TacticalLines.BOTTOM_ROUGHNESS_MODERATE: 2646 case TacticalLines.BOTTOM_ROUGHNESS_ROUGH: 2647 case TacticalLines.BOTTOM_ROUGHNESS_SMOOTH: 2648 case TacticalLines.CLUTTER_HIGH: 2649 case TacticalLines.CLUTTER_MEDIUM: 2650 case TacticalLines.CLUTTER_LOW: 2651 case TacticalLines.IMPACT_BURIAL_0: 2652 case TacticalLines.IMPACT_BURIAL_10: 2653 case TacticalLines.IMPACT_BURIAL_100: 2654 case TacticalLines.IMPACT_BURIAL_20: 2655 case TacticalLines.IMPACT_BURIAL_75: 2656 case TacticalLines.BOTTOM_CATEGORY_A: 2657 case TacticalLines.BOTTOM_CATEGORY_B: 2658 case TacticalLines.BOTTOM_CATEGORY_C: 2659 case TacticalLines.BOTTOM_TYPE_A1: 2660 case TacticalLines.BOTTOM_TYPE_A2: 2661 case TacticalLines.BOTTOM_TYPE_A3: 2662 case TacticalLines.BOTTOM_TYPE_B1: 2663 case TacticalLines.BOTTOM_TYPE_B2: 2664 case TacticalLines.BOTTOM_TYPE_B3: 2665 case TacticalLines.BOTTOM_TYPE_C1: 2666 case TacticalLines.BOTTOM_TYPE_C2: 2667 case TacticalLines.BOTTOM_TYPE_C3: 2668 case TacticalLines.SUBMERGED_CRIB: 2669 case TacticalLines.FREEFORM: 2670 shape.setFillColor(tg.get_FillColor()); 2671 break; 2672 default: 2673 break; 2674 } 2675 switch (shape.get_FillStyle()) { 2676 case 3://GraphicProperties.FILL_TYPE_RIGHT_SLANTS: 2677 rect = new Rectangle2D.Double(0, 0, 8, 8); 2678 grid = bi.createGraphics(); 2679 grid.setColor(shape.getFillColor()); 2680 grid.drawLine(0, 8, 8, 0); 2681 tp = new TexturePaint(bi, rect); 2682 shape.setTexturePaint(tp); 2683 shape.setFillColor(null); 2684 grid.dispose(); 2685 break; 2686 case 2://GraphicProperties.FILL_TYPE_LEFT_SLANTS: 2687 rect = new Rectangle2D.Double(0, 0, 8, 8); 2688 grid = bi.createGraphics(); 2689 grid.setColor(tg.get_FillColor()); 2690 grid.drawLine(0, 0, 8, 8); 2691 tp = new TexturePaint(bi, rect); 2692 shape.setTexturePaint(tp); 2693 shape.setFillColor(null); 2694 grid.dispose(); 2695 //clsUtility.WriteFile("set TexturePaint"); 2696 break; 2697 case 6://GraphicProperties.FILL_TYPE_DOTS: 2698 rect = new Rectangle2D.Double(3, 3, 8, 8); 2699 grid = bi.createGraphics(); 2700 grid.setColor(tg.get_FillColor()); 2701 grid.drawLine(3, 3, 5, 3); 2702 grid.drawLine(5, 3, 5, 5); 2703 grid.drawLine(5, 5, 3, 5); 2704 grid.drawLine(3, 5, 5, 3); 2705 tp = new TexturePaint(bi, rect); 2706 shape.setTexturePaint(tp); 2707 shape.setFillColor(null); 2708 grid.dispose(); 2709 break; 2710 case 4://GraphicProperties.FILL_TYPE_VERTICAL_LINES: 2711 rect = new Rectangle2D.Double(0, 0, 8, 8); 2712 grid = bi.createGraphics(); 2713 grid.setColor(tg.get_FillColor()); 2714 grid.drawLine(4, 0, 4, 8); 2715 tp = new TexturePaint(bi, rect); 2716 shape.setTexturePaint(tp); 2717 shape.setFillColor(null); 2718 grid.dispose(); 2719 break; 2720 case 5://GraphicProperties.FILL_TYPE_HORIZONTAL_LINES: 2721 rect = new Rectangle2D.Double(0, 0, 8, 8); 2722 grid = bi.createGraphics(); 2723 grid.setColor(tg.get_FillColor()); 2724 grid.drawLine(0, 4, 8, 4); 2725 tp = new TexturePaint(bi, rect); 2726 shape.setTexturePaint(tp); 2727 shape.setFillColor(null); 2728 grid.dispose(); 2729 break; 2730 case 1://GraphicProperties.FILL_TYPE_SOLID: 2731 //shape.set_FillColor(tg.get_FillColor()); 2732 break; 2733 default: 2734 break; 2735 } 2736 } 2737 switch (shape.get_Style()) { 2738 case 0://GraphicProperties.LINE_TYPE_SOLID: 2739 //dash=new float[1]; 2740 //dash[0]=1; 2741 dash = null; 2742 break; 2743 case 1://GraphicProperties.LINE_TYPE_DASHED: 2744 dash = new float[2]; 2745 dash[0] = 5f; 2746 dash[1] = 5f; 2747 //clsUtility.WriteFile("dashed"); 2748 break; 2749 case 2://GraphicProperties.LINE_TYPE_DOTTED: 2750 dash = new float[2]; 2751 dash[0] = 3f; 2752 dash[1] = 3f; 2753 break; 2754 case 3://GraphicProperties.LINE_TYPE_DASHDOT: 2755 dash = new float[4]; 2756 dash[0] = 8;//dash 2757 dash[1] = 4;//space 2758 dash[2] = 4;//dot 2759 dash[3] = 4;//space 2760 break; 2761 case 4://GraphicProperties.LINE_TYPE_DASHDOTDOT: 2762 dash = new float[6]; 2763 dash[0] = 8;//dash 2764 dash[1] = 4;//space 2765 dash[2] = 4;//dot 2766 dash[3] = 4;//space 2767 dash[4] = 4;//dot 2768 dash[5] = 4;//space 2769 break; 2770 default: 2771 break; 2772 } 2773 //set the shape with the default properties 2774 //the switch statement below will override specific properties as needed 2775 stroke = new BasicStroke(lineThickness, BasicStroke.CAP_ROUND, BasicStroke.JOIN_ROUND, 1, dash, 0); 2776 shape.setStroke(stroke); 2777 } 2778 } catch (Exception exc) { 2779 //clsUtility.WriteFile("error in clsMETOC.SetShapeProperties"); 2780 ErrorLogger.LogException(_className ,"SetShapeProperties", 2781 new RendererException("Failed inside SetShapeProperties", exc)); 2782 } 2783 } 2784 2785 /** 2786 * Draws an arrow to the GeneralPath object from pt1 to pt2. 2787 * 2788 * @param pt1 arrow tip 2789 * @param pt2 - arrow base 2790 * @param size - arrow size in pixels 2791 * @param lineObject - general path to draw the arrow 2792 * 2793 * @return arrow sprite 2794 */ 2795 private static void DrawArrow(POINT2 pt1, 2796 POINT2 pt2, 2797 int size, 2798 GeneralPath lineObject) { 2799 try 2800 { 2801 POINT2 ptBase = new POINT2(); 2802 POINT2 ptTemp = new POINT2(); 2803 ArrayList<POINT2> pts = new ArrayList(); 2804 ptBase = lineutility.ExtendAlongLineDouble(pt2, pt1, size); 2805 ptTemp = lineutility.ExtendDirectedLine(pt1, ptBase, ptBase, 2, size); 2806 2807 pts.add(ptTemp); 2808 pts.add(pt2); 2809 ptTemp = lineutility.ExtendDirectedLine(pt1, ptBase, ptBase, 3, size); 2810 pts.add(ptTemp); 2811 lineObject.moveTo(pts.get(0).x, pts.get(0).y); 2812 lineObject.lineTo(pts.get(1).x, pts.get(1).y); 2813 lineObject.lineTo(pts.get(2).x, pts.get(2).y); 2814 pts.clear(); 2815 pts = null; 2816 } catch (Exception exc) { 2817 ErrorLogger.LogException(_className ,"DrawArrow", 2818 new RendererException("Failed inside DrawArrow", exc)); 2819 } 2820 } 2821 /** 2822 * Returns a GeneralPath for symbols which require splines. Also returns the calculated 2823 * spline points for those symbols with additional features based on them. 2824 * @param tg 2825 * @param splinePoints2 spline points in pixels 2826 * @return 2827 */ 2828 private static GeneralPath DrawSplines(TGLight tg, 2829 ArrayList<POINT2> splinePoints2) { 2830 GeneralPath lineObject = new GeneralPath(); 2831 try { 2832 int i = 0, j = 0; 2833 int n=0,t=0; 2834 ArrayList<POINT2> splinePoints; 2835 ArrayList<POINT2> array = tg.get_Pixels(); 2836 POINT2 pt0 = new POINT2(), pt1 = new POINT2(), pt2 = new POINT2(), pt3 = new POINT2(), 2837 pt4 = new POINT2(), pt5 = new POINT2(), pt6 = new POINT2(); 2838 POINT2 pt, pt_before, pt_after, Di, p2, p3, pt_after2; 2839 double tension = 0.33; 2840 double control_scale = (tension / 0.5 * 0.175); 2841 ArrayList<POINT2> tmpArray = null; 2842 n=array.size(); 2843 //for (i = 0; i < array.size() - 1; i++) //was length-1 2844 for (i = 0; i < n - 1; i++) //was length-1 2845 { 2846 pt = array.get(i); 2847 if (i == 0) { 2848 lineObject.moveTo(pt.x, pt.y); 2849 pt_before = pt; 2850 } else { 2851 pt_before = array.get(i - 1); 2852 } 2853 2854 if (i == array.size() - 1) { 2855 pt2 = array.get(i); 2856 } else { 2857 pt2 = array.get(i + 1); 2858 } 2859 2860 if (i < array.size() - 2) { 2861 pt_after = array.get(i + 1); 2862 } else { 2863 pt_after = array.get(array.size() - 1); 2864 } 2865 2866 if (i < array.size() - 2) { 2867 pt_after2 = array.get(i + 2); 2868 } else { 2869 pt_after2 = array.get(array.size() - 1); 2870 } 2871 2872 2873 Di = new POINT2(); 2874 p2 = new POINT2(); 2875 2876 Di.x = pt_after.x - pt_before.x; 2877 Di.y = pt_after.y - pt_before.y; 2878 p2.x = pt.x + control_scale * Di.x; 2879 p2.y = pt.y + control_scale * Di.y; 2880 2881 p3 = new POINT2(); 2882 POINT2 DiPlus1 = new POINT2(); 2883 2884 DiPlus1.x = pt_after2.x - pt.x; 2885 DiPlus1.y = pt_after2.y - pt.y; 2886 p3.x = pt_after.x - control_scale * DiPlus1.x; 2887 p3.y = pt_after.y - control_scale * DiPlus1.y; 2888 2889 tmpArray = drawCubicBezier2(tg, lineObject, pt, p2, p3, pt2); 2890 2891 //ICE_OPENINGS_FROZEN needs to know which segment corresponds to each spline point 2892 if (tg.get_LineType() == TacticalLines.ICE_OPENINGS_FROZEN || 2893 tg.get_LineType() == TacticalLines.ICE_OPENINGS_FROZEN_GE) 2894 { 2895 if(tmpArray.size()>0) 2896 tmpArray.get(tmpArray.size() - 1).style = 47; //use this to differentiate the arrays 2897 } 2898 splinePoints2.addAll(tmpArray); 2899 2900 splinePoints = tmpArray; 2901 2902 switch (tg.get_LineType()) { 2903 case TacticalLines.EBB_TIDE: 2904 if (i == array.size() - 2) 2905 { 2906 if(splinePoints.size()>=2) 2907 DrawArrow(splinePoints.get(splinePoints.size() - 2), tg.Pixels.get(tg.Pixels.size() - 1), 10, lineObject); 2908 } 2909 break; 2910 case TacticalLines.FLOOD_TIDE: 2911 if (i == 0 && splinePoints.size() > 1) { 2912 //finally get the feather points 2913 //must allocate for the feather points, requires 4 additional points 2914 pt0 = splinePoints.get(0); 2915 pt1 = splinePoints.get(1); 2916 pt2 = lineutility.ExtendLineDouble(pt0, pt1, 10); 2917 pt3 = lineutility.ExtendLineDouble(pt0, pt1, 20); 2918 pt4 = lineutility.ExtendLineDouble(pt0, pt1, 30); 2919 pt5 = lineutility.ExtendDirectedLine(pt3, pt2, pt2, 3, 10); 2920 pt6 = lineutility.ExtendDirectedLine(pt4, pt3, pt3, 3, 10); 2921 2922 //first feather line 2923 lineObject.moveTo(pt3.x, pt3.y); 2924 lineObject.lineTo(pt5.x, pt5.y); 2925 //second feather line 2926 lineObject.moveTo(pt4.x, pt4.y); 2927 lineObject.lineTo(pt6.x, pt6.y); 2928 } 2929 if (i == array.size() - 2) 2930 { 2931 if(splinePoints.size()>=2) 2932 DrawArrow(splinePoints.get(splinePoints.size() - 2), tg.Pixels.get(tg.Pixels.size() - 1), 10, lineObject); 2933 } 2934 break; 2935 case TacticalLines.STREAM: 2936 case TacticalLines.JET: 2937 //if (i == 0) 2938 if (i == 0 && splinePoints.size()>1) 2939 { 2940 DrawArrow(splinePoints.get(1), splinePoints.get(0), 10, lineObject); 2941 } 2942 break; 2943 case TacticalLines.FLOOD_TIDE_GE: 2944 if (i == 0 && splinePoints.size() > 1) { 2945 //finally get the feather points 2946 //must allocate for the feather points, requires 4 additional points 2947 pt0 = splinePoints.get(0); 2948 pt1 = splinePoints.get(1); 2949 pt2 = lineutility.ExtendLineDouble(pt0, pt1, 10); 2950 pt3 = lineutility.ExtendLineDouble(pt0, pt1, 20); 2951 pt4 = lineutility.ExtendLineDouble(pt0, pt1, 30); 2952 pt5 = lineutility.ExtendDirectedLine(pt3, pt2, pt2, 3, 10); 2953 pt6 = lineutility.ExtendDirectedLine(pt4, pt3, pt3, 3, 10); 2954 2955 //first feather line 2956 lineObject.moveTo(pt3.x, pt3.y); 2957 lineObject.lineTo(pt5.x, pt5.y); 2958 //second feather line 2959 lineObject.moveTo(pt4.x, pt4.y); 2960 lineObject.lineTo(pt6.x, pt6.y); 2961 } 2962 if(i==array.size()-2)//the last point in the array 2963 { 2964 lineObject.moveTo((int)splinePoints2.get(0).x,(int)splinePoints2.get(0).y); 2965 t=splinePoints2.size(); 2966 //for(j=1;j<splinePoints2.size();j++) 2967 for(j=1;j<t;j++) 2968 lineObject.lineTo((int)splinePoints2.get(j).x,(int)splinePoints2.get(j).y); 2969 2970 if(splinePoints.size()>=2) 2971 DrawArrow(splinePoints.get(splinePoints.size() - 2), tg.Pixels.get(tg.Pixels.size() - 1), 10, lineObject); 2972 } 2973 break; 2974 case TacticalLines.EBB_TIDE_GE: 2975 if(i==array.size()-2)//the last point in the array 2976 { 2977 lineObject=new GeneralPath(); 2978 lineObject.moveTo((int)splinePoints2.get(0).x,(int)splinePoints2.get(0).y); 2979 t=splinePoints2.size(); 2980 //for(j=1;j<splinePoints2.size();j++) 2981 for(j=1;j<t;j++) 2982 lineObject.lineTo((int)splinePoints2.get(j).x,(int)splinePoints2.get(j).y); 2983 2984 if(splinePoints.size()>=2) 2985 DrawArrow(splinePoints.get(splinePoints.size() - 2), tg.Pixels.get(tg.Pixels.size() - 1), 10, lineObject); 2986 } 2987 break; 2988 case TacticalLines.JET_GE: 2989 case TacticalLines.STREAM_GE: 2990 if (i == 0 && splinePoints.size()>1) 2991 { 2992 DrawArrow(splinePoints.get(1), splinePoints.get(0), 10, lineObject); 2993 } 2994 if(i==array.size()-2)//the last point in the array 2995 { 2996 lineObject.moveTo((int)splinePoints2.get(0).x,(int)splinePoints2.get(0).y); 2997 t=splinePoints2.size(); 2998 //for(j=1;j<splinePoints2.size();j++) 2999 for(j=1;j<t;j++) 3000 lineObject.lineTo((int)splinePoints2.get(j).x,(int)splinePoints2.get(j).y); 3001 } 3002 break; 3003 case TacticalLines.ICE_OPENINGS_FROZEN_GE: 3004 case TacticalLines.ICE_OPENINGS_LEAD_GE: 3005 case TacticalLines.CABLE_GE: 3006 case TacticalLines.SEAWALL_GE: 3007 case TacticalLines.JETTY_BELOW_WATER_GE: 3008 case TacticalLines.JETTY_ABOVE_WATER_GE: 3009 case TacticalLines.RAMP_ABOVE_WATER_GE: 3010 case TacticalLines.RAMP_BELOW_WATER_GE: 3011 case TacticalLines.PIER_GE: 3012 case TacticalLines.COASTLINE_GE: 3013 case TacticalLines.DEPTH_CONTOUR_GE: 3014 case TacticalLines.DEPTH_CURVE_GE: 3015 case TacticalLines.CRACKS_GE: 3016 case TacticalLines.ESTIMATED_ICE_EDGE_GE: 3017 case TacticalLines.ICE_EDGE_GE: 3018 case TacticalLines.ISOPLETHS_GE: 3019 case TacticalLines.ISODROSOTHERM_GE: 3020 case TacticalLines.ISOTACH_GE: 3021 case TacticalLines.ISOTHERM_GE: 3022 case TacticalLines.UPPER_AIR_GE: 3023 case TacticalLines.ISOBAR_GE: 3024 case TacticalLines.HOLD_GE: 3025 case TacticalLines.BRDGHD_GE: 3026 if(splinePoints2!=null && !splinePoints2.isEmpty()) 3027 { 3028 lineObject=new GeneralPath(); 3029 if(i==array.size()-2)//the last point in the array 3030 { 3031 lineObject.moveTo((int)splinePoints2.get(0).x,(int)splinePoints2.get(0).y); 3032 t=splinePoints2.size(); 3033 //for(j=1;j<splinePoints2.size();j++) 3034 for(j=1;j<t;j++) 3035 lineObject.lineTo((int)splinePoints2.get(j).x,(int)splinePoints2.get(j).y); 3036 } 3037 } 3038 break; 3039 case TacticalLines.ICE_EDGE_RADAR: 3040 t=splinePoints.size(); 3041 //for (j = 0; j < splinePoints.size() - 1; j++) 3042 for (j = 0; j < t - 1; j++) 3043 { 3044 pt0 = new POINT2(splinePoints.get(j).x, splinePoints.get(j).y); 3045 pt2 = lineutility.ExtendAngledLine(splinePoints.get(j), splinePoints.get(j + 1), pt0, 45, 5); 3046 pt1 = new POINT2(splinePoints.get(j).x, splinePoints.get(j).y); 3047 pt3 = lineutility.ExtendAngledLine(splinePoints.get(j), splinePoints.get(j + 1), pt1, -45, 5); 3048 lineObject.moveTo(splinePoints.get(j).x, splinePoints.get(j).y); 3049 lineObject.lineTo(pt2.x, pt2.y); 3050 lineObject.moveTo(splinePoints.get(j).x, splinePoints.get(j).y); 3051 lineObject.lineTo(pt3.x, pt3.y); 3052 3053 pt0 = new POINT2(splinePoints.get(j).x, splinePoints.get(j).y); 3054 pt2 = lineutility.ExtendAngledLine(splinePoints.get(j), splinePoints.get(j + 1), pt0, 135, 5); 3055 pt1 = new POINT2(splinePoints.get(j).x, splinePoints.get(j).y); 3056 pt3 = lineutility.ExtendAngledLine(splinePoints.get(j), splinePoints.get(j + 1), pt1, -135, 5); 3057 lineObject.moveTo(splinePoints.get(j).x, splinePoints.get(j).y); 3058 lineObject.lineTo(pt2.x, pt2.y); 3059 lineObject.moveTo(splinePoints.get(j).x, splinePoints.get(j).y); 3060 lineObject.lineTo(pt3.x, pt3.y); 3061 } 3062 break; 3063 case TacticalLines.ICE_EDGE_RADAR_GE: 3064 t=splinePoints.size(); 3065 //for (j = 0; j < splinePoints.size() - 1; j++) 3066 for (j = 0; j < t - 1; j++) 3067 { 3068 pt0 = new POINT2(splinePoints.get(j).x, splinePoints.get(j).y); 3069 pt2 = lineutility.ExtendAngledLine(splinePoints.get(j), splinePoints.get(j + 1), pt0, 45, 5); 3070 pt1 = new POINT2(splinePoints.get(j).x, splinePoints.get(j).y); 3071 pt3 = lineutility.ExtendAngledLine(splinePoints.get(j), splinePoints.get(j + 1), pt1, -45, 5); 3072 lineObject.moveTo(splinePoints.get(j).x, splinePoints.get(j).y); 3073 lineObject.lineTo(pt2.x, pt2.y); 3074 lineObject.moveTo(splinePoints.get(j).x, splinePoints.get(j).y); 3075 lineObject.lineTo(pt3.x, pt3.y); 3076 3077 pt0 = new POINT2(splinePoints.get(j).x, splinePoints.get(j).y); 3078 pt2 = lineutility.ExtendAngledLine(splinePoints.get(j), splinePoints.get(j + 1), pt0, 135, 5); 3079 pt1 = new POINT2(splinePoints.get(j).x, splinePoints.get(j).y); 3080 pt3 = lineutility.ExtendAngledLine(splinePoints.get(j), splinePoints.get(j + 1), pt1, -135, 5); 3081 lineObject.moveTo(splinePoints.get(j).x, splinePoints.get(j).y); 3082 lineObject.lineTo(pt2.x, pt2.y); 3083 lineObject.moveTo(splinePoints.get(j).x, splinePoints.get(j).y); 3084 lineObject.lineTo(pt3.x, pt3.y); 3085 } 3086 if(i==array.size()-2)//the last point in the array 3087 { 3088 lineObject.moveTo((int)splinePoints2.get(0).x,(int)splinePoints2.get(0).y); 3089 t=splinePoints2.size(); 3090 //for(j=1;j<splinePoints2.size();j++) 3091 for(j=1;j<t;j++) 3092 lineObject.lineTo((int)splinePoints2.get(j).x,(int)splinePoints2.get(j).y); 3093 } 3094 break; 3095 case TacticalLines.CRACKS_SPECIFIC_LOCATION: 3096 t=splinePoints.size(); 3097 //for (j = 0; j < splinePoints.size() - 1; j++) 3098 for (j = 0; j < t - 1; j++) 3099 { 3100 //get perpendicular points (point pair) 3101 pt0 = splinePoints.get(j + 1); 3102 pt1 = lineutility.ExtendDirectedLine(splinePoints.get(j), splinePoints.get(j + 1), pt0, 2, 5); 3103 lineObject.moveTo(pt1.x, pt1.y); 3104 pt1 = lineutility.ExtendDirectedLine(splinePoints.get(j), splinePoints.get(j + 1), pt0, 3, 5); 3105 lineObject.lineTo(pt1.x, pt1.y); 3106 } 3107 break; 3108 case TacticalLines.CRACKS_SPECIFIC_LOCATION_GE: 3109 t=splinePoints.size(); 3110 //for (j = 0; j < splinePoints.size() - 1; j++) 3111 for (j = 0; j < t - 1; j++) 3112 { 3113 //get perpendicular points (point pair) 3114 pt0 = splinePoints.get(j + 1); 3115 pt1 = lineutility.ExtendDirectedLine(splinePoints.get(j), splinePoints.get(j + 1), pt0, 2, 5); 3116 lineObject.moveTo(pt1.x, pt1.y); 3117 pt1 = lineutility.ExtendDirectedLine(splinePoints.get(j), splinePoints.get(j + 1), pt0, 3, 5); 3118 lineObject.lineTo(pt1.x, pt1.y); 3119 } 3120 if(i==array.size()-2)//the last point in the array 3121 { 3122 lineObject.moveTo((int)splinePoints2.get(0).x,(int)splinePoints2.get(0).y); 3123 t=splinePoints2.size(); 3124 //for(j=1;j<splinePoints2.size();j++) 3125 for(j=1;j<t;j++) 3126 lineObject.lineTo((int)splinePoints2.get(j).x,(int)splinePoints2.get(j).y); 3127 } 3128 break; 3129 default: 3130 break; 3131 } 3132 } 3133 } 3134 catch (Exception exc) { 3135 ErrorLogger.LogException(_className ,"DrawSplines", 3136 new RendererException("Failed inside DrawSplines", exc)); 3137 } 3138 return lineObject; 3139 } 3140 3141 /** 3142 * Calculates a point on a segment using a ratio of the segment length. 3143 * This function is used for calculating control points on Bezier curves. 3144 * 3145 * @param P0 the 1st point on the segment. 3146 * @param P1 the last point on the segment 3147 * @param ratio the fraction of the segment length 3148 * 3149 * @return calculated point on the P0-P1 segment. 3150 */ 3151 private static POINT2 getPointOnSegment(POINT2 P0, POINT2 P1, double ratio) { 3152 //return {x: (P0.x + ((P1.x - P0.x) * ratio)), y: (P0.y + ((P1.y - P0.y) * ratio))}; 3153 //var pt:Point=new Point(); 3154 POINT2 pt = new POINT2(); 3155 try 3156 { 3157 pt.x = P0.x + (P1.x - P0.x) * ratio; 3158 pt.y = P0.y + (P1.y - P0.y) * ratio; 3159 } 3160 catch (Exception exc) 3161 { 3162 ErrorLogger.LogException(_className ,"getPointOnSegment", 3163 new RendererException("Failed inside getPointOnSegment", exc)); 3164 } 3165 return pt; 3166 } 3167 3168 /** 3169 * This function will trace a cubic approximation of the cubic Bezier 3170 * It will calculate a series of (control point/Destination point] which 3171 * will be used to draw quadratic Bezier starting from P0 3172 * 3173 * @param lineObject - the sprite to use for drawing 3174 * @param P0 - 1st client point 3175 * @param P1 - 1st control point for a cubic Bezier 3176 * @param P2 - 2nd control point 3177 * @param P3 - 2nd client point 3178 * 3179 * @return an array of points along the spline at linetype specific intervals 3180 */ 3181 private static ArrayList drawCubicBezier2( 3182 TGLight tg, 3183 GeneralPath lineObject, 3184 POINT2 P0, 3185 POINT2 P1, 3186 POINT2 P2, 3187 POINT2 P3) 3188 { 3189 ArrayList<POINT2> array = new ArrayList(); 3190 try { 3191 // this stuff may be unnecessary 3192 // calculates the useful base points 3193 POINT2 PA = getPointOnSegment(P0, P1, 0.75); 3194 POINT2 PB = getPointOnSegment(P3, P2, 0.75); 3195 3196 // get 1/16 of the [P3, P0] segment 3197 double dx = (P3.x - P0.x) / 16d; 3198 double dy = (P3.y - P0.y) / 16d; 3199 3200 // calculates control point 1 3201 POINT2 Pc_1 = getPointOnSegment(P0, P1, 0.375); 3202 3203 // calculates control point 2 3204 POINT2 Pc_2 = getPointOnSegment(PA, PB, 0.375); 3205 Pc_2.x -= dx; 3206 Pc_2.y -= dy; 3207 3208 // calculates control point 3 3209 POINT2 Pc_3 = getPointOnSegment(PB, PA, 0.375); 3210 Pc_3.x += dx; 3211 Pc_3.y += dy; 3212 3213 // calculates control point 4 3214 POINT2 Pc_4 = getPointOnSegment(P3, P2, 0.375); 3215 3216 // calculates the 3 anchor points 3217 POINT2 Pa_1 = lineutility.MidPointDouble(Pc_1, Pc_2, 0); 3218 POINT2 Pa_2 = lineutility.MidPointDouble(PA, PB, 0); 3219 POINT2 Pa_3 = lineutility.MidPointDouble(Pc_3, Pc_4, 0); 3220 switch (tg.get_LineType()) { //draw the solid curve for these 3221 case TacticalLines.ISOBAR: 3222 case TacticalLines.UPPER_AIR: 3223 case TacticalLines.ISODROSOTHERM: 3224 case TacticalLines.ICE_EDGE: 3225 case TacticalLines.CRACKS: 3226 case TacticalLines.DEPTH_CURVE: 3227 case TacticalLines.DEPTH_CONTOUR: 3228 case TacticalLines.COASTLINE: 3229 case TacticalLines.PIER: 3230 case TacticalLines.RAMP_ABOVE_WATER: 3231 case TacticalLines.JETTY_ABOVE_WATER: 3232 case TacticalLines.SEAWALL: 3233 case TacticalLines.CABLE: 3234 case TacticalLines.ICE_OPENINGS_LEAD: 3235 case TacticalLines.ISOTACH: 3236 case TacticalLines.ISOTHERM: 3237 case TacticalLines.ISOPLETHS: 3238 case TacticalLines.ESTIMATED_ICE_EDGE: 3239 case TacticalLines.RAMP_BELOW_WATER: 3240 case TacticalLines.JETTY_BELOW_WATER: 3241 lineObject.moveTo(P0.x, P0.y); 3242 lineObject.curveTo(P1.x, P1.y, P2.x, P2.y, P3.x, P3.y); 3243 return array; 3244 case TacticalLines.HOLD://added 1-3-11 3245 case TacticalLines.BRDGHD://added 1-3-11 3246 lineObject.moveTo(P0.x, P0.y); 3247 lineObject.curveTo(P1.x, P1.y, P2.x, P2.y, P3.x, P3.y); 3248 //return if no fill, these points are for fill 3249 if(tg.get_FillColor()==null || tg.get_FillColor().getAlpha()<2) 3250 return array; 3251 break; 3252 case TacticalLines.ICE_OPENINGS_LEAD_GE: 3253 case TacticalLines.CABLE_GE: 3254 case TacticalLines.SEAWALL_GE: 3255 case TacticalLines.JETTY_BELOW_WATER_GE: 3256 case TacticalLines.JETTY_ABOVE_WATER_GE: 3257 case TacticalLines.RAMP_ABOVE_WATER_GE: 3258 case TacticalLines.RAMP_BELOW_WATER_GE: 3259 case TacticalLines.PIER_GE: 3260 case TacticalLines.COASTLINE_GE: 3261 case TacticalLines.DEPTH_CONTOUR_GE: 3262 case TacticalLines.DEPTH_CURVE_GE: 3263 case TacticalLines.CRACKS_GE: 3264 case TacticalLines.ESTIMATED_ICE_EDGE_GE: 3265 case TacticalLines.ICE_EDGE_GE: 3266 case TacticalLines.ISOPLETHS_GE: 3267 case TacticalLines.ISOTACH_GE: 3268 case TacticalLines.ISOTHERM_GE: 3269 case TacticalLines.ISOBAR_GE: 3270 case TacticalLines.UPPER_AIR_GE: 3271 case TacticalLines.ISODROSOTHERM_GE: 3272 case TacticalLines.ICE_OPENINGS_FROZEN: 3273 case TacticalLines.ICE_OPENINGS_FROZEN_GE: 3274 case TacticalLines.ICE_EDGE_RADAR: 3275 case TacticalLines.ICE_EDGE_RADAR_GE: 3276 case TacticalLines.CRACKS_SPECIFIC_LOCATION: 3277 case TacticalLines.CRACKS_SPECIFIC_LOCATION_GE: 3278 case TacticalLines.EBB_TIDE: 3279 case TacticalLines.FLOOD_TIDE: 3280 case TacticalLines.EBB_TIDE_GE: 3281 case TacticalLines.FLOOD_TIDE_GE: 3282 case TacticalLines.JET: 3283 case TacticalLines.STREAM: 3284 case TacticalLines.JET_GE: 3285 case TacticalLines.STREAM_GE: 3286 case TacticalLines.HOLD_GE: 3287 case TacticalLines.BRDGHD_GE: 3288 lineObject.moveTo(P0.x, P0.y); 3289 lineObject.curveTo(P1.x, P1.y, P2.x, P2.y, P3.x, P3.y); 3290 //do not return, we still need the spline points 3291 //to claculate other features 3292 break; 3293 default: 3294 //the rest of them must use the calculated curve points 3295 break; 3296 } 3297 //var sprite:Sprite; 3298 int j = 0; 3299 double distance; 3300 int n = 0; 3301 double x = 0, y = 0, increment = 0; 3302 POINT2 pt0, pt1, pt2; 3303 double t; 3304 POINT2 pt; 3305 array.clear(); 3306 //distance=clsUtility.Distance2(P0,Pa_1); 3307 //add the curve points to tg.Pixels 3308 switch (tg.get_LineType()) { 3309 case TacticalLines.HOLD://added these 1-3-11. need small increment because these 3310 case TacticalLines.BRDGHD://points are used for fill which needs to confrom to the outline 3311 case TacticalLines.HOLD_GE://added these 1-3-11. need small increment because these 3312 case TacticalLines.BRDGHD_GE://points are used for fill which needs to confrom to the outline 3313 increment = 3.0; 3314 break; 3315 case TacticalLines.ICE_EDGE_RADAR: 3316 increment = 10.0; 3317 break; 3318 case TacticalLines.ICE_OPENINGS_FROZEN: 3319 case TacticalLines.ICE_OPENINGS_FROZEN_GE: 3320 case TacticalLines.CRACKS_SPECIFIC_LOCATION: 3321 case TacticalLines.CRACKS_SPECIFIC_LOCATION_GE: 3322 //increment = 12.0; 3323 increment = 7.0; 3324 break; 3325 default: 3326 increment = 10.0; 3327 break; 3328 } 3329 3330 distance = lineutility.CalcDistanceDouble(P0, Pa_1); 3331 if(distance<increment) 3332 distance=increment; 3333 n = (int) (distance / increment); 3334 3335 pt0 = P0; 3336 pt1 = Pc_1; 3337 pt2 = Pa_1; 3338 for (j = 0; j < n; j++) { 3339 t = (double) j * (increment / distance); 3340 x = (1d - t) * (1d - t) * pt0.x + 2 * (1d - t) * t * pt1.x + t * t * pt2.x; 3341 y = (1d - t) * (1d - t) * pt0.y + 2 * (1d - t) * t * pt1.y + t * t * pt2.y; 3342 pt = new POINT2(x, y); 3343 //array.push(pt); 3344 array.add(pt); 3345 } 3346 //distance=clsUtility.Distance2(Pa_1,Pa_2); 3347 distance = lineutility.CalcDistanceDouble(Pa_1, Pa_2); 3348 3349 //add the curve points to tg.Pixels 3350 n = (int) (distance / increment); 3351 pt0 = Pa_1; 3352 pt1 = Pc_2; 3353 pt2 = Pa_2; 3354 for (j = 0; j < n; j++) { 3355 t = (double) j * (increment / distance); 3356 x = (1d - t) * (1d - t) * pt0.x + 2 * (1d - t) * t * pt1.x + t * t * pt2.x; 3357 y = (1d - t) * (1d - t) * pt0.y + 2 * (1d - t) * t * pt1.y + t * t * pt2.y; 3358 pt = new POINT2(x, y); 3359 array.add(pt); 3360 } 3361 3362 //distance=clsUtility.Distance2(Pa_2,Pa_3); 3363 distance = lineutility.CalcDistanceDouble(Pa_2, Pa_3); 3364 //add the curve points to tg.Pixels 3365 n = (int) (distance / increment); 3366 pt0 = Pa_2; 3367 pt1 = Pc_3; 3368 pt2 = Pa_3; 3369 for (j = 0; j < n; j++) { 3370 t = (double) j * (increment / distance); 3371 x = (1d - t) * (1d - t) * pt0.x + 2 * (1d - t) * t * pt1.x + t * t * pt2.x; 3372 y = (1d - t) * (1d - t) * pt0.y + 2 * (1d - t) * t * pt1.y + t * t * pt2.y; 3373 pt = new POINT2(x, y); 3374 array.add(pt); 3375 } 3376 //distance=clsUtility.Distance2(Pa_3,P3); 3377 distance = lineutility.CalcDistanceDouble(Pa_3, P3); 3378 //add the curve points to tg.Pixels 3379 n = (int) (distance / increment); 3380 pt0 = Pa_3; 3381 pt1 = Pc_4; 3382 pt2 = P3; 3383 for (j = 0; j < n; j++) { 3384 t = (double) j * (increment / distance); 3385 x = (1d - t) * (1d - t) * pt0.x + 2 * (1d - t) * t * pt1.x + t * t * pt2.x; 3386 y = (1d - t) * (1d - t) * pt0.y + 2 * (1d - t) * t * pt1.y + t * t * pt2.y; 3387 pt = new POINT2(x, y); 3388 array.add(pt); 3389 } 3390 } 3391 catch (Exception exc) { 3392 ErrorLogger.LogException(_className ,"drawCubicBezier2", 3393 new RendererException("Failed inside drawCubicBezier2", exc)); 3394 } 3395 return array; 3396 } 3397 3398 /** 3399 * 3400 * Called by Splines2TG to get straight channel lines for splines. 3401 * 3402 * @param tg - TGlight 3403 * 3404 * @return An ArrayList to use for building the parallel splines 3405 */ 3406// private static ArrayList ParallelLines(TGLight tg,int rev) { 3407// ArrayList<POINT2> channelPoints2 = new ArrayList(); 3408// try { 3409// double[] pLinePoints = new double[tg.Pixels.size() * 2]; 3410// double[] channelPoints = new double[6 * tg.Pixels.size()]; 3411// int j = 0; 3412// int n=tg.Pixels.size(); 3413// //for (j = 0; j < tg.Pixels.size(); j++) 3414// for (j = 0; j < n; j++) 3415// { 3416// pLinePoints[2 * j] = tg.Pixels.get(j).x; 3417// pLinePoints[2 * j + 1] = tg.Pixels.get(j).y; 3418// } 3419// int numPoints = tg.Pixels.size(); 3420// int channelWidth = 20; 3421// int usePtr = 0; 3422// ArrayList<Shape2> shapes = null; 3423// 3424// try { 3425// CELineArray.CGetChannel2Double(pLinePoints, pLinePoints, channelPoints, numPoints, numPoints, (int) TacticalLines.CHANNEL, channelWidth, usePtr, shapes,rev); 3426// } catch (Exception e) { 3427// ErrorLogger.LogException(_className, "ParallelLines", 3428// new RendererException("Failed inside ParallelLines", e)); 3429// } 3430// 3431// POINT2 pt2 = null; 3432// int style = 0; 3433// n=channelPoints.length; 3434// //for (j = 0; j < channelPoints.length / 3; j++) 3435// for (j = 0; j < n / 3; j++) 3436// { 3437// pt2 = new POINT2(channelPoints[3 * j], channelPoints[3 * j + 1], style); 3438// channelPoints2.add(pt2); 3439// } 3440// } catch (Exception exc) { 3441// ErrorLogger.LogException(_className, "ParallelLines", 3442// new RendererException("Failed inside ParallelLines", exc)); 3443// } 3444// return channelPoints2; 3445// } 3446 /** 3447 * Call this function with segment 3448 * @param Pixels a segment of tg.Pixels 3449 * @return 3450 */ 3451 private static ArrayList ParallelLines2(ArrayList<POINT2> Pixels,int rev) { 3452 ArrayList<POINT2> channelPoints2 = new ArrayList(); 3453 try { 3454 double[] pLinePoints = new double[Pixels.size() * 2]; 3455 double[] channelPoints = new double[6 * Pixels.size()]; 3456 int j = 0; 3457 int n=Pixels.size(); 3458 //for (j = 0; j < Pixels.size(); j++) 3459 for (j = 0; j < n; j++) 3460 { 3461 pLinePoints[2 * j] = Pixels.get(j).x; 3462 pLinePoints[2 * j + 1] = Pixels.get(j).y; 3463 } 3464 int numPoints = Pixels.size(); 3465 int channelWidth = 20; 3466 int usePtr = 0; 3467 ArrayList<Shape2> shapes = null; 3468 3469 try { 3470 CELineArray.CGetChannel2Double(pLinePoints, pLinePoints, channelPoints, numPoints, numPoints, (int) TacticalLines.CHANNEL, channelWidth, usePtr, shapes,rev); 3471 } catch (Exception e) { 3472 ErrorLogger.LogException(_className, "ParallelLines2", 3473 new RendererException("Failed inside ParallelLines2", e)); 3474 } 3475 3476 POINT2 pt2 = null; 3477 int style = 0; 3478 n=channelPoints.length; 3479 //for (j = 0; j < channelPoints.length / 3; j++) 3480 for (j = 0; j < n / 3; j++) 3481 { 3482 pt2 = new POINT2(channelPoints[3 * j], channelPoints[3 * j + 1], style); 3483 channelPoints2.add(pt2); 3484 } 3485 } catch (Exception exc) { 3486 ErrorLogger.LogException(_className, "ParallelLines2", 3487 new RendererException("Failed inside ParallelLines2", exc)); 3488 } 3489 return channelPoints2; 3490 } 3491}