lxnodemanager.java

基于Java的地图数据管理软件。使用MySQL数据库管理系统。

package net.aetherial.gis.jiaotongbu.outputJTB.txtOutput.module.gpsdata.lxld.lx;

import org.w3c.dom.Node;
import net.aetherial.gis.surface.ItemValue;
import java.util.Vector;
import net.aetherial.gis.publicuse.TrackOper;
import net.aetherial.gis.our.auto.check.repeattrk.TrackRectangle;
import org.w3c.dom.NodeList;
import java.util.Hashtable;
import java.util.Enumeration;
import java.util.StringTokenizer;

/**
 * <p>Title: </p>
 *
 * <p>Description: </p>
 *
 * <p>Copyright: Copyright (c) 2004</p>
 *
 * <p>Company: </p>
 *
 * @author not attributable
 * @version 1.0
 */
public class LXNodeManager {
  private Node[] trks = null;

  public LXNodeManager() {

    trks = ItemValue.getTracks();
    if (trks == null) {
      return;
    }
    System.out.print("开始航迹归类合并，共有航迹" + trks.length + "条....");
    for (int i = 0; i < trks.length; i++) {
      if (notInserted(trks[i])) {
        System.out.println("   trks[" + i + "]:" +
                           ItemValue.getTracksName(trks[i]));
        String name, number, grade, key = "无名路" + i;
        name = ItemValue.getTracksName(trks[i]);
        number = ItemValue.getTracksNumber(trks[i]);
//        grade = ItemValue.getTracksGrade(trks[i]);
//      System.out.print(name + " --> ");
        if (number.length() > 3) {
          key = number;
        }
        else {

          if (name.replaceAll("\\[村道\\]", "").indexOf("(") > 0) {
            key = name.substring(0, name.indexOf("("));
          }
          else {
//            name.indexOf("",2);
            if (name.replaceAll("\\[村道\\]", "").lastIndexOf("(") > 0) {
              key = name.substring(0, name.lastIndexOf("(")).replaceAll("\\(",
                  "").replaceAll("\\)", "");
            }
            else {
              key = name.replaceAll("\\(", "").replaceAll("\\)", "");
            }
          }
        }

        if (key.replaceAll("\\[村道\\]", "").trim().length() < 1) {
          key = "无名路" + i;
        }

        //      System.out.println(key);
//        if(ItemValue.getTracksDistance(trks[i]) > 150){
        Vector nodes = (Vector) ItemValue.namedTracks.get(key);
        if (nodes == null) {
          nodes = new Vector();
          ItemValue.namedTracks.put(key, nodes);
        }
        //        normalizatTrk(trks[i]);

        putInto(nodes, trks[i], -1);
//        }
//        Node[] temp = TrackOper.getIntersectTracks(trks, trks[i]);
//        for (int j = 0; temp != null && j < temp.length; j++) {
//          for (int n = 0; n < nodes.size(); n++) {
//            if (isNearBE(temp[j], (Node) nodes.get(n)) &&
//                isCanLink(temp[j], (Node) nodes.get(n))) {
//              putInto(nodes, temp[j]);
//              break;
//            }
//          }
//
//        }
//        this.printNamedTracks();
      }
    }
    Enumeration keys = ItemValue.namedTracks.keys();
    while (keys.hasMoreElements()) {
      normailizeTrks( (Vector) ItemValue.namedTracks.get(keys.nextElement()));
    }

    System.out.println("结束,共形成航迹：" + ItemValue.namedTracks.keySet().size());
//    this.printNamedTracks();
//    new TrackNearBE(trks);
//    trks = TracksShouldLink.removeNodeInThis(trks);

  }

  private void printNamedTracks() {
    Enumeration keys = ItemValue.namedTracks.keys();
    Vector temp = null;
    int i = 0;
    System.out.println("      ************************** Print nameTracks");
    while (keys.hasMoreElements()) {
      temp = (Vector) ItemValue.namedTracks.get(keys.nextElement());
      for (int j = 0; j < temp.size(); j++) {
        System.out.println("      namedTracks[" + i + "][" + j + "]" +
                           ItemValue.getTracksName( (Node) temp.get(j)));
      }
      i++;
    }
    System.out.println("      **************************");
  }

  private void printVectorTracks(Vector ve, String name) {
    System.out.println("      PrintVector --" + name);
    for (int j = 0; j < ve.size(); j++) {
      System.out.println("         " + name + "[" + j + "]:" +
                         ItemValue.getTracksName( (Node) ve.get(j)));
    }
  }

  private Node reverse(Node trk) {
    if (trk == null) {
      return null;
    }
    NodeList nl1 = ItemValue.getTracksPoint(trk);
    String[] x = new String[nl1.getLength()], y = new String[nl1.getLength()],
        z = new String[nl1.getLength()];
    for (int i = 0; i < nl1.getLength(); i++) {
      x[i] = ItemValue.getTracksPointX(nl1.item(i));
      y[i] = ItemValue.getTracksPointY(nl1.item(i));
      z[i] = ItemValue.getTracksPointZ(nl1.item(i));
    }

//    double startX = Double.parseDouble(x[0]);
//    double startY = Double.parseDouble(y[0]);
//    double endX = Double.parseDouble(x[x.length-1]);
//    double endY = Double.parseDouble(y[y.length-1]);
//
//    if(endX < startX || endY < startY){
    int length = nl1.getLength();
    for (int i = 0; i < length; i++) {
      nl1.item(i).getChildNodes().item(0).getChildNodes().item(0).setNodeValue(
          x[length - 1 - i]);
      nl1.item(i).getChildNodes().item(1).getChildNodes().item(0).setNodeValue(
          y[length - 1 - i]);
      nl1.item(i).getChildNodes().item(2).getChildNodes().item(0).setNodeValue(
          z[length - 1 - i]);
    }
//    }
    return trk;
  }

  private Node normalize(Node trk) {
    if (trk == null) {
      return null;
    }
    NodeList nl1 = ItemValue.getTracksPoint(trk);

    double startX = Double.parseDouble(ItemValue.getTracksPointX(nl1.item(0)));
    double startY = Double.parseDouble(ItemValue.getTracksPointY(nl1.item(0)));
    double endX = Double.parseDouble(ItemValue.getTracksPointX(nl1.item(nl1.
        getLength() - 1)));
    double endY = Double.parseDouble(ItemValue.getTracksPointY(nl1.item(nl1.
        getLength() - 1)));

    if (endX < startX) {
      return reverse(trk);
    }
    else if (endX == startX && endY < startY) {
      return reverse(trk);
    }
    return trk;
  }

  private boolean notInserted(Node trk) {
    boolean result = true;
    Hashtable nodes = ItemValue.namedTracks;
    Enumeration keys = nodes.keys();
    while (keys.hasMoreElements()) {
      String key = (String) keys.nextElement();
      Vector value = (Vector) nodes.get(key);
      if (value != null) {
        for (int i = 0; i < value.size(); i++) {
          if (trk.equals(value.get(i))) {
            return false;
          }
        }
      }
    }
    return result;
  }

  private boolean xiangTong(Vector nodes, Node trk) {
    boolean result = false;
    if (this.isRepeatLD(trk)) {
      return false;
    }
    NodeList nl1 = ItemValue.getTracksPoint(trk);
    String bx1, by1, bx2, by2, mx1, my1, mx2, my2;
    int l1, l2;
    l1 = nl1.getLength();
    mx1 = ItemValue.getTracksPointX(nl1.item(nl1.getLength() / 2-1));
    my1 = ItemValue.getTracksPointY(nl1.item(nl1.getLength() / 2-1));
    bx1 = ItemValue.getTracksPointX(nl1.item(0));
    by1 = ItemValue.getTracksPointY(nl1.item(0));
    for (int i = 0; i < nodes.size(); i++) {
      NodeList nl2 = ItemValue.getTracksPoint( (Node) nodes.get(i));

      l2 = nl2.getLength();

      bx2 = ItemValue.getTracksPointX(nl2.item(0));
      by2 = ItemValue.getTracksPointY(nl2.item(0));

      mx2 = ItemValue.getTracksPointX(nl2.item(nl2.getLength() / 2-1));
      my2 = ItemValue.getTracksPointY(nl2.item(nl2.getLength() / 2-1));

      if (bx1.equals(bx2) &&
          by1.equals(by2) &&
          mx1.equals(mx2) &&
          my1.equals(my2) &&
          l1 == l2) {
        System.out.println(" 1repeat to:" +
                           ItemValue.getTracksName( (Node) nodes.get(i)));
        return true;
      }

      bx2 = ItemValue.getTracksPointX(nl2.item(nl2.getLength() - 1));
      by2 = ItemValue.getTracksPointY(nl2.item(nl2.getLength() - 1));

      if (l2 % 2 == 0) {
        mx2 = ItemValue.getTracksPointX(nl2.item(nl2.getLength() / 2 ));
        my2 = ItemValue.getTracksPointY(nl2.item(nl2.getLength() / 2 ));
      }
      if (bx1.equals(bx2) &&
          by1.equals(by2) &&
          mx1.equals(mx2) &&
          my1.equals(my2) &&
          l1 == l2) {
        System.out.println(" 2repeat to:" +
                           ItemValue.getTracksName( (Node) nodes.get(i)));
        return true;
      }
//      mx2 = ItemValue.getTracksPointX(nl2.item(nl2.getLength() / 2));
//      my2 = ItemValue.getTracksPointX(nl2.item(nl2.getLength() / 2));


    }

    return false;
  }

  private boolean isRepeatLD(Node trk) {
    String ldNumber = ItemValue.getTracks_ld_original_number(trk).trim();
    if (ldNumber.equals("")) {
      return false;
    }
    if (ldNumber.indexOf("CanNotBeCut") != -1) {
      return true;
    }
    else {
      StringTokenizer st = new StringTokenizer(ldNumber, "||");
      if (st.countTokens() == 4) {
        return true;
      }
      else {
        return false;
      }
    }
  }

  private boolean putInto(Vector nodes, Node trk, int index) {
//      boolean result = true;
    if (nodes == null || trk == null) {
      return false;
    }
    if (xiangTong(nodes, trk)) {
      System.out.println("发现重复路段：" + ItemValue.getTracksName(trk) + " " +
                         ItemValue.getTracksT2(trk) + " " +
                         ItemValue.getTracksT3(trk));
      return false;
    }
    if (index > -1) {
//      int i = nodes.indexOf(compare);
      nodes.add(index, trk);
    }
    else {
      nodes.add(trk);
    }
//      boolean alreadyInside = false;
//      for(int i = 0; !alreadyInside && i < nodes.size(); i++){
//        alreadyInside = trk.equals(nodes.get(i));
//      }
//      if(!alreadyInside){
//        if(nodes.size() < 1){
////          NodeList nl1 = ItemValue.getTracksPoint(trk);
////      System.out.println("start "+ItemValue.getTracksPointX(nl1.item(0))+" "+ItemValue.getTracksPointY(nl1.item(0)));
//          nodes.add(normalize(trk));
////           nl1 = ItemValue.getTracksPoint(trk);
////       System.out.println("end "+ItemValue.getTracksPointX(nl1.item(0))+" "+ItemValue.getTracksPointY(nl1.item(0)));
//        }else{
//          boolean added = false;
//          for (int i = 0; !added && i < nodes.size(); i++) {
//            int shunXu = getNodesShunxu( (Node) nodes.get(i), trk);
//            switch (shunXu) {
//              case 0:
//                nodes.add(i, reverse(trk));
//                added = true;
//                break;
//              case 1:
//                nodes.add(i, trk);
//                added = true;
//                break;
//              case 2:
//                nodes.add(i + 1, trk);
//                added = true;
//                break;
//              case 3:
//                nodes.add(i + 1, reverse(trk));
//                added = true;
//                break;
//
//            }
//          }
//          if(!added){
//
//                nodes.add(normalize(trk));
////            added = true;
//
//          }
//
//
//          isOrphen = !added;
//        }
//
//      }
    return true;
////  arrange(nodes);
  }