[31] | 1 | /************************************************************************************ |
---|
| 2 | * Copyright (C) 2008 by Politehnica University of Bucharest and Rutgers University |
---|
| 3 | * All rights reserved. |
---|
| 4 | * Refer to LICENSE for terms and conditions of use. |
---|
| 5 | ***********************************************************************************/ |
---|
| 6 | package vnsim.vehicular.routePlan.selfRouted; |
---|
| 7 | |
---|
| 8 | |
---|
| 9 | import java.util.ArrayList; |
---|
| 10 | import java.io.Serializable; |
---|
| 11 | |
---|
| 12 | import vnsim.map.object.Cross; |
---|
| 13 | import vnsim.map.object.Globals; |
---|
| 14 | import vnsim.map.object.Point; |
---|
| 15 | import vnsim.map.object.Road; |
---|
| 16 | import vnsim.map.utils.GPSutil; |
---|
| 17 | |
---|
| 18 | public class RoadAreaUtils implements Serializable { |
---|
| 19 | |
---|
| 20 | /** <code>serialVersionUID</code> */ |
---|
| 21 | private static final long serialVersionUID = -5883719321862303634L; |
---|
| 22 | |
---|
| 23 | public ArrayList<Integer> mainRoads; // indicii drumurilor principale |
---|
| 24 | |
---|
| 25 | // din Globals.map.roads |
---|
| 26 | |
---|
| 27 | public ArrayList<MajorRoadArea> distinctAreas; |
---|
| 28 | |
---|
| 29 | public RoadAreaUtils() { |
---|
| 30 | mainRoads = new ArrayList<Integer>(); |
---|
| 31 | distinctAreas = new ArrayList<MajorRoadArea>(); |
---|
| 32 | } |
---|
| 33 | |
---|
| 34 | public void splitRoads() { |
---|
| 35 | int i, j, k; |
---|
| 36 | Road r; |
---|
| 37 | Point p; |
---|
| 38 | for (i = 0; i < Globals.map.roads.size(); i++) { |
---|
| 39 | r = Globals.map.roads.get(i); |
---|
| 40 | //if (((r.getRoadinfo())[1] == 49) || ((r.getRoadinfo())[1] == 50)) { |
---|
| 41 | // if (((r.getRoadinfo())[1] >= 49) || ((r.getRoadinfo())[1] <= 51)) { |
---|
| 42 | if (((r.getRoadinfo())[1] == 49)) { |
---|
| 43 | mainRoads.add(new Integer(i)); |
---|
| 44 | } |
---|
| 45 | } |
---|
| 46 | int dim = mainRoads.size(); |
---|
| 47 | System.out.println("I have: " + dim + " primary roads"); |
---|
| 48 | if (dim > 0) { |
---|
| 49 | for (i = 0; i < Globals.map.roads.size(); i++) { |
---|
| 50 | r = Globals.map.roads.get(i); |
---|
| 51 | for (j = 0; j < r.points.size(); j++) { |
---|
| 52 | p = r.points.get(j); |
---|
| 53 | p.areaCode = new AreaCode(dim); |
---|
| 54 | for (k = 0; k < dim; k++) { |
---|
| 55 | p.areaCode.code[k] = -1; |
---|
| 56 | } |
---|
| 57 | |
---|
| 58 | } |
---|
| 59 | } |
---|
| 60 | |
---|
| 61 | for (i = 0; i < mainRoads.size(); i++) { |
---|
| 62 | r = Globals.map.roads.get(mainRoads.get(i).intValue()); |
---|
| 63 | for (j = 0; j < r.points.size(); j++) { |
---|
| 64 | p = r.points.get(j); |
---|
| 65 | p.areaCode.code[i] = 2; |
---|
| 66 | |
---|
| 67 | } |
---|
| 68 | } |
---|
| 69 | |
---|
| 70 | } |
---|
| 71 | |
---|
| 72 | } |
---|
| 73 | |
---|
| 74 | public boolean inDirection(float xM1, float yM1, float xM2, float yM2, |
---|
| 75 | float xm1, float ym1, float xm2, float ym2) { |
---|
| 76 | float cosM, cosm, sinM, sinm; |
---|
| 77 | float dxM, dxm, dyM, dym; |
---|
| 78 | |
---|
| 79 | double angleM = 0.0, anglem = 0.0; |
---|
| 80 | |
---|
| 81 | dxM = xM2 - xM1; |
---|
| 82 | dxm = xm2 - xm1; |
---|
| 83 | dyM = yM2 - yM1; |
---|
| 84 | dym = ym2 - ym1; |
---|
| 85 | cosM = (dxM / ((float) (Math.sqrt((double) (dxM * dxM + dyM * dyM))))); |
---|
| 86 | cosm = (dxm / ((float) (Math.sqrt((double) (dxm * dxm + dym * dym))))); |
---|
| 87 | sinM = (dyM / ((float) (Math.sqrt((double) (dxM * dxM + dyM * dyM))))); |
---|
| 88 | sinm = (dym / ((float) (Math.sqrt((double) (dxm * dxm + dym * dym))))); |
---|
| 89 | |
---|
| 90 | // System.out.println(" "+(Math.sqrt((double) (xM1 * xM2 + yM1 * yM2)))+ |
---|
| 91 | // "..."+(Math.sqrt((double) (xm1 * xm2 + ym1 * ym2)))); |
---|
| 92 | |
---|
| 93 | if (cosM > 1.0f) { |
---|
| 94 | cosM = 1.0f; |
---|
| 95 | } |
---|
| 96 | if (cosm > 1.0f) { |
---|
| 97 | cosm = 1.0f; |
---|
| 98 | } |
---|
| 99 | if (cosM < -1.0f) { |
---|
| 100 | cosM = -1.0f; |
---|
| 101 | } |
---|
| 102 | if (cosm < -1.0f) { |
---|
| 103 | cosm = -1.0f; |
---|
| 104 | } |
---|
| 105 | if (sinM > 1.0f) { |
---|
| 106 | sinM = 1.0f; |
---|
| 107 | } |
---|
| 108 | if (sinm > 1.0f) { |
---|
| 109 | sinm = 1.0f; |
---|
| 110 | } |
---|
| 111 | if (sinM < -1.0f) { |
---|
| 112 | sinM = -1.0f; |
---|
| 113 | } |
---|
| 114 | if (sinm < -1.0f) { |
---|
| 115 | sinm = -1.0f; |
---|
| 116 | } |
---|
| 117 | |
---|
| 118 | // //First angle |
---|
| 119 | if (sinM == 0) { |
---|
| 120 | if (cosM > 0) { |
---|
| 121 | angleM = 0; |
---|
| 122 | } else { |
---|
| 123 | angleM = Math.PI; |
---|
| 124 | } |
---|
| 125 | |
---|
| 126 | } |
---|
| 127 | if (cosM == 0) { |
---|
| 128 | if (sinM > 0) { |
---|
| 129 | angleM = Math.PI / 2; |
---|
| 130 | } else { |
---|
| 131 | angleM = 0 - Math.PI / 2; |
---|
| 132 | } |
---|
| 133 | } |
---|
| 134 | |
---|
| 135 | if (sinM > 0 && cosM > 0) { |
---|
| 136 | angleM = Math.acos(cosM); |
---|
| 137 | |
---|
| 138 | } |
---|
| 139 | if (sinM < 0 && cosM < 0) { |
---|
| 140 | angleM = Math.acos(cosM); |
---|
| 141 | angleM = (Math.PI - angleM) + Math.PI; |
---|
| 142 | |
---|
| 143 | } |
---|
| 144 | if (sinM < 0 && cosM > 0) { |
---|
| 145 | angleM = Math.acos(cosM); |
---|
| 146 | |
---|
| 147 | angleM = Math.PI + Math.PI - angleM; |
---|
| 148 | |
---|
| 149 | } |
---|
| 150 | |
---|
| 151 | if (sinM > 0 && cosM < 0) { |
---|
| 152 | angleM = Math.acos(cosM); |
---|
| 153 | |
---|
| 154 | } |
---|
| 155 | // Second angle |
---|
| 156 | if (sinm == 0) { |
---|
| 157 | if (cosm > 0) { |
---|
| 158 | anglem = 0; |
---|
| 159 | } else { |
---|
| 160 | anglem = Math.PI; |
---|
| 161 | } |
---|
| 162 | |
---|
| 163 | } |
---|
| 164 | if (cosm == 0) { |
---|
| 165 | if (sinm > 0) { |
---|
| 166 | anglem = Math.PI / 2; |
---|
| 167 | } else { |
---|
| 168 | anglem = 0 - Math.PI / 2; |
---|
| 169 | } |
---|
| 170 | } |
---|
| 171 | |
---|
| 172 | if (sinm > 0 && cosm > 0) { |
---|
| 173 | anglem = Math.acos(cosm); |
---|
| 174 | |
---|
| 175 | } |
---|
| 176 | if (sinm < 0 && cosm < 0) { |
---|
| 177 | anglem = Math.acos(cosm); |
---|
| 178 | anglem = (Math.PI - anglem) + Math.PI; |
---|
| 179 | |
---|
| 180 | } |
---|
| 181 | if (sinm < 0 && cosm > 0) { |
---|
| 182 | anglem = Math.acos(cosm); |
---|
| 183 | |
---|
| 184 | anglem = Math.PI + Math.PI - anglem; |
---|
| 185 | |
---|
| 186 | } |
---|
| 187 | |
---|
| 188 | if (sinm > 0 && cosm < 0) { |
---|
| 189 | anglem = Math.acos(cosm); |
---|
| 190 | |
---|
| 191 | } |
---|
| 192 | |
---|
| 193 | // System.out.println("Unghi MARE=" + angleM + " si in grade" |
---|
| 194 | // + ((angleM * 180) / Math.PI)); |
---|
| 195 | // System.out.println("Unghi mic=" + anglem + " si in grade" |
---|
| 196 | // + ((anglem * 180) / Math.PI)); |
---|
| 197 | if (Math.abs(angleM - anglem) >= Math.PI) { |
---|
| 198 | if (anglem > angleM) { |
---|
| 199 | // on the left side |
---|
| 200 | return false; |
---|
| 201 | } else { |
---|
| 202 | // on the right side |
---|
| 203 | return true; |
---|
| 204 | } |
---|
| 205 | } else { |
---|
| 206 | |
---|
| 207 | if (anglem > angleM) { |
---|
| 208 | // on the right side |
---|
| 209 | return true; |
---|
| 210 | } else { |
---|
| 211 | // on the left side |
---|
| 212 | return false; |
---|
| 213 | } |
---|
| 214 | } |
---|
| 215 | |
---|
| 216 | } |
---|
| 217 | ArrayList<Mark> currentMarks ; |
---|
| 218 | ArrayList<Mark> nextMarks ; |
---|
| 219 | public void splitMap() { |
---|
| 220 | splitRoads(); |
---|
| 221 | currentMarks = new ArrayList<Mark>(); |
---|
| 222 | nextMarks = new ArrayList<Mark>(); |
---|
| 223 | int i, ii, j, k, l, mainRoadIdx; |
---|
| 224 | Road r, crossedRoad; |
---|
| 225 | Point p, cp; |
---|
| 226 | Cross c; |
---|
| 227 | java.awt.geom.Point2D.Float main1, main2, second1, second2; |
---|
| 228 | int idxM1, idxM2, idxS1, idxS2; |
---|
| 229 | Mark m; |
---|
| 230 | |
---|
| 231 | for (ii = 0; ii < mainRoads.size(); ii++) { |
---|
| 232 | mainRoadIdx = mainRoads.get(ii).intValue(); |
---|
| 233 | r = Globals.map.roads.get(mainRoadIdx); |
---|
| 234 | |
---|
| 235 | for (j = 0; j < r.crosses.size(); j++) { |
---|
| 236 | c = r.crosses.get(j); |
---|
| 237 | crossedRoad = Globals.map.roads.get(c.getCrossRoadIndex()); |
---|
| 238 | main1 = new java.awt.geom.Point2D.Float(); |
---|
| 239 | main2 = new java.awt.geom.Point2D.Float(); |
---|
| 240 | second1 = new java.awt.geom.Point2D.Float(); |
---|
| 241 | second2 = new java.awt.geom.Point2D.Float(); |
---|
| 242 | |
---|
| 243 | if (c.getPointIndex() == 0) { |
---|
| 244 | idxM1 = 0; |
---|
| 245 | idxM2 = 1; |
---|
| 246 | |
---|
| 247 | } else { |
---|
| 248 | if (c.getPointIndex() == r.points.size() - 1) { |
---|
| 249 | idxM1 = r.points.size() - 2; |
---|
| 250 | idxM2 = r.points.size() - 1; |
---|
| 251 | } else { |
---|
| 252 | idxM1 = c.getPointIndex() - 1; |
---|
| 253 | idxM2 = c.getPointIndex() + 1; |
---|
| 254 | } |
---|
| 255 | } |
---|
| 256 | if (c.getCrossPointIndex() == 0) { |
---|
| 257 | idxS1 = 0; |
---|
| 258 | idxS2 = 1; |
---|
| 259 | |
---|
| 260 | } else { |
---|
| 261 | if (c.getCrossPointIndex() == crossedRoad.points.size() - 1) { |
---|
| 262 | idxS1 = crossedRoad.points.size() - 2; |
---|
| 263 | idxS2 = crossedRoad.points.size() - 1; |
---|
| 264 | |
---|
| 265 | } else { |
---|
| 266 | |
---|
| 267 | idxS1 = c.getCrossPointIndex() - 1; |
---|
| 268 | idxS2 = c.getCrossPointIndex() + 1; |
---|
| 269 | |
---|
| 270 | } |
---|
| 271 | } |
---|
| 272 | main1.y = (float) GPSutil.getMetersLatitude( |
---|
| 273 | Globals.map.minPoint, r.points.get(idxM1)); |
---|
| 274 | main1.x = (float) GPSutil.getMetersLongitude( |
---|
| 275 | Globals.map.minPoint, r.points.get(idxM1)); |
---|
| 276 | |
---|
| 277 | main2.y = (float) GPSutil.getMetersLatitude( |
---|
| 278 | Globals.map.minPoint, r.points.get(idxM2)); |
---|
| 279 | main2.x = (float) GPSutil.getMetersLongitude( |
---|
| 280 | Globals.map.minPoint, r.points.get(idxM2)); |
---|
| 281 | |
---|
| 282 | second1.y = (float) GPSutil.getMetersLatitude( |
---|
| 283 | Globals.map.minPoint, crossedRoad.points.get(idxS1)); |
---|
| 284 | second1.x = (float) GPSutil.getMetersLongitude( |
---|
| 285 | Globals.map.minPoint, crossedRoad.points.get(idxS1)); |
---|
| 286 | |
---|
| 287 | second2.y = (float) GPSutil.getMetersLatitude( |
---|
| 288 | Globals.map.minPoint, crossedRoad.points.get(idxS2)); |
---|
| 289 | second2.x = (float) GPSutil.getMetersLongitude( |
---|
| 290 | Globals.map.minPoint, crossedRoad.points.get(idxS2)); |
---|
| 291 | |
---|
| 292 | crossedRoad.points.get(c.getCrossPointIndex()).areaCode.code[ii] = 2; |
---|
| 293 | |
---|
| 294 | if (inDirection(main1.x, main1.y, main2.x, main2.y, second1.x, |
---|
| 295 | second1.y, second2.x, second2.y)) { |
---|
| 296 | nextMarks |
---|
| 297 | .add(new Mark(ii, 0, c.getCrossRoadIndex(), idxS1)); |
---|
| 298 | nextMarks |
---|
| 299 | .add(new Mark(ii, 1, c.getCrossRoadIndex(), idxS2)); |
---|
| 300 | } else { |
---|
| 301 | nextMarks |
---|
| 302 | .add(new Mark(ii, 1, c.getCrossRoadIndex(), idxS1)); |
---|
| 303 | nextMarks |
---|
| 304 | .add(new Mark(ii, 0, c.getCrossRoadIndex(), idxS2)); |
---|
| 305 | |
---|
| 306 | } |
---|
| 307 | |
---|
| 308 | } |
---|
| 309 | // /////////////////////////////////////////////////////////////////////////// |
---|
| 310 | while (nextMarks.size() != 0) { |
---|
| 311 | currentMarks = nextMarks; |
---|
| 312 | nextMarks = new ArrayList<Mark>(); |
---|
| 313 | |
---|
| 314 | for (i = 0; i < currentMarks.size(); i++) { |
---|
| 315 | m = currentMarks.get(i); |
---|
| 316 | if (m.pos >= mainRoads.size()) { |
---|
| 317 | System.out |
---|
| 318 | .println("Incorect position for area code!To many major roads!"); |
---|
| 319 | continue; |
---|
| 320 | } |
---|
| 321 | if (m.pos < 0) { |
---|
| 322 | System.out |
---|
| 323 | .println("Incorect position for area code!Negative value!"); |
---|
| 324 | continue; |
---|
| 325 | } |
---|
| 326 | r = Globals.map.roads.get(m.roadId); |
---|
| 327 | p = r.points.get(m.pointId); |
---|
| 328 | if (p.areaCode.code[m.pos] != -1) { |
---|
| 329 | continue; |
---|
| 330 | } else { |
---|
| 331 | p.areaCode.code[m.pos] = (byte) m.val; |
---|
| 332 | if (m.pointId == 0) { |
---|
| 333 | nextMarks.add(new Mark(m.pos, m.val, m.roadId, 1)); |
---|
| 334 | } else { |
---|
| 335 | if (m.pointId == r.points.size() - 1) { |
---|
| 336 | nextMarks.add(new Mark(m.pos, m.val, m.roadId, |
---|
| 337 | m.pointId - 1)); |
---|
| 338 | } else { |
---|
| 339 | nextMarks.add(new Mark(m.pos, m.val, m.roadId, |
---|
| 340 | m.pointId - 1)); |
---|
| 341 | nextMarks.add(new Mark(m.pos, m.val, m.roadId, |
---|
| 342 | m.pointId + 1)); |
---|
| 343 | |
---|
| 344 | } |
---|
| 345 | } |
---|
| 346 | for (j = 0; j < r.crosses.size(); j++) { |
---|
| 347 | c = r.crosses.get(j); |
---|
| 348 | cp = Globals.map.roads.get(c.getCrossRoadIndex()).points |
---|
| 349 | .get(c.getCrossPointIndex()); |
---|
| 350 | if (cp.equals(p)) { |
---|
| 351 | nextMarks.add(new Mark(m.pos, m.val, c |
---|
| 352 | .getCrossRoadIndex(), c |
---|
| 353 | .getCrossPointIndex())); |
---|
| 354 | } |
---|
| 355 | } |
---|
| 356 | |
---|
| 357 | } |
---|
| 358 | } |
---|
| 359 | } |
---|
| 360 | // /////////////////////////////////////////////////////////////////////////// |
---|
| 361 | } |
---|
| 362 | |
---|
| 363 | } |
---|
| 364 | |
---|
| 365 | public void selectDistinctRoadAreas() { |
---|
| 366 | |
---|
| 367 | int i, j, k; |
---|
| 368 | Road r; |
---|
| 369 | Point p; |
---|
| 370 | boolean found = false; |
---|
| 371 | for (i = 0; i < Globals.map.roads.size(); i++) { |
---|
| 372 | r = Globals.map.roads.get(i); |
---|
| 373 | for (j = 0; j < r.points.size(); j++) { |
---|
| 374 | |
---|
| 375 | p = r.points.get(j); |
---|
| 376 | // if(p.areaCode.code==null){ |
---|
| 377 | // continue; |
---|
| 378 | // } |
---|
| 379 | if (distinctAreas.size() != 0) { |
---|
| 380 | // if (!isOnBorder(p.areaCode.code)) { |
---|
| 381 | found = false; |
---|
| 382 | for (k = 0; k < distinctAreas.size(); k++) { |
---|
| 383 | if (distinctAreas.get(k).areaCodeString |
---|
| 384 | .equals(p.areaCode.areaCodeToString())) { |
---|
| 385 | found = true; |
---|
| 386 | p.areaCode.belongingTo = distinctAreas.get(k); |
---|
| 387 | p.areaCode.code = null; |
---|
| 388 | break; |
---|
| 389 | } |
---|
| 390 | } |
---|
| 391 | if (found == false) { |
---|
| 392 | p.areaCode.belongingTo = new MajorRoadArea(p.areaCode); |
---|
| 393 | p.areaCode.code = null; |
---|
| 394 | distinctAreas.add(p.areaCode.belongingTo); |
---|
| 395 | } |
---|
| 396 | // } |
---|
| 397 | } else { |
---|
| 398 | // if (!isOnBorder(p.areaCode.code)) { |
---|
| 399 | p.areaCode.belongingTo = new MajorRoadArea(p.areaCode); |
---|
| 400 | p.areaCode.code = null; |
---|
| 401 | distinctAreas.add(p.areaCode.belongingTo); |
---|
| 402 | // } |
---|
| 403 | } |
---|
| 404 | |
---|
| 405 | } |
---|
| 406 | } |
---|
| 407 | |
---|
| 408 | for (i = 0; i < distinctAreas.size(); i++) { |
---|
| 409 | distinctAreas.get(i).constructArea(); |
---|
| 410 | } |
---|
| 411 | |
---|
| 412 | } |
---|
| 413 | |
---|
| 414 | public void mergeAreas() { |
---|
| 415 | int i, j, k, u, v; |
---|
| 416 | Road r; |
---|
| 417 | Point p1, p2; |
---|
| 418 | ArrayList<MajorRoadArea> changed = new ArrayList<MajorRoadArea>(); |
---|
| 419 | ArrayList<MajorRoadArea> changedWith = new ArrayList<MajorRoadArea>(); |
---|
| 420 | ArrayList<Integer> changedIdx = new ArrayList<Integer>(); |
---|
| 421 | Cross c; |
---|
| 422 | for (i = 0; i < Globals.map.roads.size(); i++) { |
---|
| 423 | r = Globals.map.roads.get(i); |
---|
| 424 | if (i == 5360) { |
---|
| 425 | System.out.println("STACK"); |
---|
| 426 | } |
---|
| 427 | |
---|
| 428 | for (j = 0; j < r.points.size() - 1; j++) { |
---|
| 429 | p1 = r.points.get(j); |
---|
| 430 | p2 = r.points.get(j + 1); |
---|
| 431 | if (!p1.areaCode.belongingTo.areaCodeString |
---|
| 432 | .equals(p2.areaCode.belongingTo.areaCodeString)) { |
---|
| 433 | |
---|
| 434 | if ((!isOnBorder(p1.areaCode.belongingTo.areaCodeByte)) |
---|
| 435 | && (!isOnBorder(p2.areaCode.belongingTo.areaCodeByte))) { |
---|
| 436 | changed.add(new MajorRoadArea(p2.areaCode.belongingTo)); |
---|
| 437 | changedWith.add(new MajorRoadArea( |
---|
| 438 | p1.areaCode.belongingTo)); |
---|
| 439 | changedIdx.add(new Integer(this.distinctAreas |
---|
| 440 | .indexOf(p2.areaCode.belongingTo))); |
---|
| 441 | for (v = 0; v < changedWith.size() - 1; v++) { |
---|
| 442 | if (changedWith.get(v).areaCodeString |
---|
| 443 | .equals(p2.areaCode.belongingTo.areaCodeString)) { |
---|
| 444 | this.distinctAreas.get( |
---|
| 445 | changedIdx.get(v).intValue()).move( |
---|
| 446 | p1.areaCode.belongingTo); |
---|
| 447 | changedWith.get(v) |
---|
| 448 | .move(p1.areaCode.belongingTo); |
---|
| 449 | } |
---|
| 450 | } |
---|
| 451 | p2.areaCode.belongingTo.move(p1.areaCode.belongingTo); |
---|
| 452 | |
---|
| 453 | } |
---|
| 454 | } |
---|
| 455 | |
---|
| 456 | } |
---|
| 457 | |
---|
| 458 | for (j = 0; j < r.crosses.size(); j++) { |
---|
| 459 | c = r.crosses.get(j); |
---|
| 460 | p1 = r.points.get(c.getPointIndex()); |
---|
| 461 | p2 = Globals.map.roads.get(c.getCrossRoadIndex()).points.get(c |
---|
| 462 | .getCrossPointIndex()); |
---|
| 463 | if (!p1.areaCode.belongingTo.areaCodeString |
---|
| 464 | .equals(p2.areaCode.belongingTo.areaCodeString)) { |
---|
| 465 | |
---|
| 466 | if ((!isOnBorder(p1.areaCode.belongingTo.areaCodeByte)) |
---|
| 467 | && (!isOnBorder(p2.areaCode.belongingTo.areaCodeByte))) { |
---|
| 468 | changed.add(new MajorRoadArea(p2.areaCode.belongingTo)); |
---|
| 469 | changedWith.add(new MajorRoadArea( |
---|
| 470 | p1.areaCode.belongingTo)); |
---|
| 471 | changedIdx.add(new Integer(this.distinctAreas |
---|
| 472 | .indexOf(p2.areaCode.belongingTo))); |
---|
| 473 | for (v = 0; v < changedWith.size() - 1; v++) { |
---|
| 474 | if (changedWith.get(v).areaCodeString |
---|
| 475 | .equals(p2.areaCode.belongingTo.areaCodeString)) { |
---|
| 476 | this.distinctAreas.get( |
---|
| 477 | changedIdx.get(v).intValue()).move( |
---|
| 478 | p1.areaCode.belongingTo); |
---|
| 479 | changedWith.get(v) |
---|
| 480 | .move(p1.areaCode.belongingTo); |
---|
| 481 | } |
---|
| 482 | } |
---|
| 483 | p2.areaCode.belongingTo.move(p1.areaCode.belongingTo); |
---|
| 484 | |
---|
| 485 | } |
---|
| 486 | } |
---|
| 487 | } |
---|
| 488 | } |
---|
| 489 | // for (i = 0; i < changed.size(); i++) { |
---|
| 490 | // System.out.println(" **** " + changed.get(i).areaCodeString |
---|
| 491 | // + " cu " + changedWith.get(i).areaCodeString); |
---|
| 492 | // |
---|
| 493 | // } |
---|
| 494 | ArrayList<Integer> borders; |
---|
| 495 | for (i = 0; i < mainRoads.size(); i++) { |
---|
| 496 | r = Globals.map.roads.get(mainRoads.get(i).intValue()); |
---|
| 497 | for (j = 0; j < r.points.size() - 1; j++) { |
---|
| 498 | p1 = r.points.get(j); |
---|
| 499 | p2 = r.points.get(j + 1); |
---|
| 500 | if (!p1.areaCode.belongingTo.areaCodeString |
---|
| 501 | .equals(p2.areaCode.belongingTo.areaCodeString)) { |
---|
| 502 | for (u = 0; u < changed.size(); u++) { |
---|
| 503 | k = -1; |
---|
| 504 | k = isOnBorderOf(p1.areaCode.belongingTo.areaCodeByte, |
---|
| 505 | changed.get(u).areaCodeByte); |
---|
| 506 | if (k > -1) { |
---|
| 507 | borders = getBordersOf(p1.areaCode.belongingTo.areaCodeByte); |
---|
| 508 | |
---|
| 509 | p1.areaCode.belongingTo.move(changedWith.get(u)); |
---|
| 510 | p1.areaCode.belongingTo.areaCodeByte[k] = 2; |
---|
| 511 | for (k = 0; k < borders.size(); k++) { |
---|
| 512 | p1.areaCode.belongingTo.areaCodeByte[borders |
---|
| 513 | .get(k).intValue()] = 2; |
---|
| 514 | } |
---|
| 515 | p1.areaCode.belongingTo.setStringValue(); |
---|
| 516 | |
---|
| 517 | } |
---|
| 518 | k = -1; |
---|
| 519 | k = isOnBorderOf(p2.areaCode.belongingTo.areaCodeByte, |
---|
| 520 | changed.get(u).areaCodeByte); |
---|
| 521 | if (k > -1) { |
---|
| 522 | borders = getBordersOf(p2.areaCode.belongingTo.areaCodeByte); |
---|
| 523 | |
---|
| 524 | p2.areaCode.belongingTo.move(changedWith.get(u)); |
---|
| 525 | for (k = 0; k < borders.size(); k++) { |
---|
| 526 | p2.areaCode.belongingTo.areaCodeByte[borders |
---|
| 527 | .get(k).intValue()] = 2; |
---|
| 528 | } |
---|
| 529 | p2.areaCode.belongingTo.setStringValue(); |
---|
| 530 | |
---|
| 531 | } |
---|
| 532 | } |
---|
| 533 | } |
---|
| 534 | |
---|
| 535 | } |
---|
| 536 | |
---|
| 537 | } |
---|
| 538 | |
---|
| 539 | } |
---|
| 540 | |
---|
| 541 | public boolean isOnBorder(byte[] area) { |
---|
| 542 | int i; |
---|
| 543 | for (i = 0; i < area.length; i++) { |
---|
| 544 | if (area[i] == 2) { |
---|
| 545 | return true; |
---|
| 546 | } |
---|
| 547 | } |
---|
| 548 | return false; |
---|
| 549 | } |
---|
| 550 | |
---|
| 551 | // /area1Code is the border of area2 |
---|
| 552 | public int isOnBorderOf(byte[] area1, byte[] area2) { |
---|
| 553 | int i; |
---|
| 554 | |
---|
| 555 | int j = -1; |
---|
| 556 | for (i = 0; i < area1.length; i++) { |
---|
| 557 | if (area1[i] != area2[i]) { |
---|
| 558 | if (area1[i] != 2) { |
---|
| 559 | return -1; |
---|
| 560 | } else { |
---|
| 561 | continue; |
---|
| 562 | } |
---|
| 563 | } |
---|
| 564 | } |
---|
| 565 | |
---|
| 566 | return 0; |
---|
| 567 | } |
---|
| 568 | |
---|
| 569 | public ArrayList<Integer> getBordersOf(byte[] area1) { |
---|
| 570 | int i; |
---|
| 571 | ArrayList<Integer> rez = new ArrayList<Integer>(); |
---|
| 572 | int j = -1; |
---|
| 573 | for (i = 0; i < area1.length; i++) { |
---|
| 574 | if (area1[i] == 2) { |
---|
| 575 | rez.add(new Integer(i)); |
---|
| 576 | } |
---|
| 577 | } |
---|
| 578 | |
---|
| 579 | return rez; |
---|
| 580 | } |
---|
| 581 | |
---|
| 582 | public boolean inSameArea(byte[] area1, byte[] area2) { |
---|
| 583 | int i; |
---|
| 584 | if (area1.length != area2.length) { |
---|
| 585 | return false; |
---|
| 586 | } else { |
---|
| 587 | for (i = 0; i < area1.length; i++) { |
---|
| 588 | if (area1[i] != area2[i]) { |
---|
| 589 | if ((area1[i] != 2) && (area2[i] != 2)) { |
---|
| 590 | return false; |
---|
| 591 | } |
---|
| 592 | } |
---|
| 593 | } |
---|
| 594 | return true; |
---|
| 595 | } |
---|
| 596 | } |
---|
| 597 | |
---|
| 598 | public int getAreaFor(Point p) { |
---|
| 599 | int i; |
---|
| 600 | for (i = 0; i < distinctAreas.size(); i++) { |
---|
| 601 | if (distinctAreas.get(i).areaCodeString |
---|
| 602 | .equals(p.areaCode.belongingTo.areaCodeString)) { |
---|
| 603 | return i; |
---|
| 604 | } |
---|
| 605 | } |
---|
| 606 | return -1; |
---|
| 607 | |
---|
| 608 | } |
---|
| 609 | |
---|
| 610 | } |
---|