lxnodemanager.java

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

  private Node getMaxTrack(Vector nodes) {
    Node result = null;
    double dis = 0, temp;
    for (int i = 0; nodes != null && i < nodes.size(); i++) {
      temp = ItemValue.getTracksDistance( (Node) nodes.get(i));
      if (dis < temp) {
        result = (Node) nodes.get(i);
        dis = temp;
      }
    }
    return normalize(result);
  }

  private Node getLeft(Vector orphen, Vector newNodes, Node mainNode) {
    Node result = null;
    boolean reverse = false;
    double dis;
    double min = 999999999d;
    NodeList nl1 = ItemValue.getTracksPoint(mainNode);
    for (int i = 0; i < orphen.size(); i++) {
//        reverse = false;
      Node current = (Node) orphen.get(i);
      if (!mainNode.equals(current)) {

        NodeList nl2 = ItemValue.getTracksPoint(current);
        double b1b2 = getDisOfTPoint(nl1.item(0), nl2.item(0));
        double b1e2 = getDisOfTPoint(nl1.item(0),
                                     nl2.item(nl2.getLength() - 1));

        dis = Math.min(b1b2, b1e2);
        if (dis < min) {

          result = (Node) orphen.get(i);
          if (b1b2 < b1e2) {
            result = reverse(result);
          }
          min = dis;
        }
      }
    }

    if (min < 150) {
      return result;
    }
    else {
      return null;
    }
  }

  private Node getRight(Vector nodes, Vector newNodes, Node trk) {
    Node result = null;
    boolean reverse = false;
    NodeList nl1 = ItemValue.getTracksPoint(trk);
    double dis;
    double min = 999999999d;
    for (int i = 0; i < nodes.size(); i++) {
      Node current = (Node) nodes.get(i);
//        reverse = false;
      if (!trk.equals(current)) {

        NodeList nl2 = ItemValue.getTracksPoint(current);
        double e1b2 = getDisOfTPoint(nl1.item(nl1.getLength() - 1),
                                     nl2.item(0));
        double e1e2 = getDisOfTPoint(nl1.item(nl1.getLength() - 1),
                                     nl2.item(nl2.getLength() - 1));
        dis = Math.min(e1b2, e1e2);
        if (dis < min) {

          result = (Node) nodes.get(i);
          if (e1e2 < e1b2) {
            result = reverse(result);
          }
          min = dis;
        }
      }
    }

    if (min < 150) {
      return result;
    }
    else {
      return null;
    }
  }

  private void normailizeTrks(Vector nodes) {
    Vector newNodes = new Vector();
    Vector orphan = new Vector();
    orphan.addAll(nodes);
    Node main = getMaxTrack(nodes);

    if (main != null) {
      newNodes.add(main);
      orphan.remove(main);
      //         boolean noMoreLeft = false;
      Node leftOne, rightOne = null;
      Node temp = main;
      boolean foundLeft = true;
      int i = 0;
//        temp = main;
      while (i < orphan.size()) {

        leftOne = getLeft(orphan, newNodes, temp);
        if (putInto(newNodes, leftOne, newNodes.indexOf(temp))) {
          orphan.remove(leftOne);
          temp = leftOne;
          i = 0;
        }
        else {
          i++;
//            putInto(orphen,leftOne,-1);
        }
//        System.out.println("    Left * main = " + ItemValue.getTracksName(temp));
//        this.printVectorTracks(orphan, "orphan");
//        System.out.println("");
//        this.printVectorTracks(newNodes, "newNodes");

//           nodes.remove(leftOne);
      }

      temp = main;
      i = 0;
      while (i < orphan.size()) {
        rightOne = getRight(orphan, newNodes, temp);
        if (putInto(newNodes, rightOne, newNodes.indexOf(temp) + 1)) {
          orphan.remove(rightOne);
          temp = rightOne;
          i = 0;
//            i++;
        }
        else {
          i++;
//            putInto(orphen,rightOne,-1);
        }
//        System.out.println("    right * main = " + ItemValue.getTracksName(main));
//        this.printVectorTracks(orphan, "orphan");
//        System.out.println("");
//        this.printVectorTracks(newNodes, "newNodes");

//           nodes.remove(rightOne);
      }
      nodes.clear();
      nodes.addAll(newNodes);
      if (orphan.size() > 1) {
//        System.out.println("  ===============orphan.size() =" + orphan.size());
        normailizeTrks(orphan);
      }
      nodes.addAll(orphan);
//        checkBE(nodes);
    }
  }

  private void checkBE(Vector nodes) {

  }

//      int shunXu = 4 ;
//      Node trk1,trk2;
//      boolean nengJiaRu = true;
//      Vector orphen = new Vector(), trunk = new Vector();
//      trunk.add(nodes.get(0));
//      int i = 1;
//      boolean foundOrphen = false;
//      for (;  !foundOrphen && i < nodes.size(); i++) {
//        trk1 = (Node) nodes.get(i-1);
//        trk2 = (Node) nodes.get(i);
//
//             shunXu = getNodesShunxu( trk1, trk2);
//            switch (shunXu) {
//              case 0:// impossible
//              case 1:// impossible
//              case 2:// impossible
//                ;
//              case 3:
////                trunk.add(trk1);
//                trunk.add(trk2);
//                break;
//              case 4: orphen.add(trk2);foundOrphen = true;
////            nodes.add(trk1);
//
//            }
//          }
//          for(int j=i; j < nodes.size(); j++){
//            orphen.add(nodes.get(j));
//          }
//          while( orphen.size() > 0 && nengJiaRu ){
//            for(int o = 0; o < orphen.size(); o++){
//              Node trk = (Node) orphen.get(o);
//              if(nengJiaRu = putInto(trunk,trk,null)){
//                orphen.remove(trk);break;
//              }
//            }
//          }
////          for( i = 0; i < orphen.size(); i++){
////              trunk.add(orphen.get(i));
////          }
//          nodes = trunk;

//}

  /**
   *  两节点顺序的关系
   * 0 代表首1 首2相连
   * 1 代表首1 尾2相连
   * 2 代表尾1 首2相连
   * 3 代表尾1 尾2相连
   * 4 不相连
   */
  public int getNodesShunxu(Node n1, Node n2) {
    NodeList nl1 = ItemValue.getTracksPoint(n1);
    NodeList nl2 = ItemValue.getTracksPoint(n2);
    double b1b2 = getDisOfTPoint(nl1.item(0), nl2.item(0));
    double b1e2 = getDisOfTPoint(nl1.item(0), nl2.item(nl2.getLength() - 1));
    double e1b2 = getDisOfTPoint(nl1.item(nl1.getLength() - 1), nl2.item(0));
    double e1e2 = getDisOfTPoint(nl1.item(nl1.getLength() - 1),
                                 nl2.item(nl2.getLength() - 1));
    double min = Math.min(Math.min(b1b2, b1e2), Math.min(e1b2, e1e2));
    if (min > TrackRectangle.NEAR_DISTANCE) {
      return 4;
    }
    if (min == b1b2) {
      return 0;
    }
    else if (min == b1e2) {
      return 1;
    }
    else if (min == e1b2) {
      return 2;
    }
    else {
      return 3;
    }
//    if ( (b1b2 < b1e2) && (b1b2 < e1b2) && (b1b2 < e1e2)) {
//      return 0;
//    }
//    else if ( (b1e2 < b1b2) && (b1e2 < e1b2) && (b1e2 < e1e2)) {
//      return 1;
//    }
//    else if ( (e1b2 < b1b2) && (e1b2 < b1e2) && (e1b2 < e1e2)) {
//      return 2;
//    }
//    else {
//      return 3;
//    }
  }

  private void arrange(Vector nodes) {
    if (nodes == null && nodes.size() < 2) {
      return;
    }
    Node temp = null;
    for (int i = 0; i < nodes.size(); i++) {
      int left = getLeftNode(nodes, i);
      if (left > i) {
        temp = (Node) nodes.get(i);
        nodes.set(i, nodes.get(left));
        nodes.set(left, temp);
      }
    }
  }

  private int getLeftNode(Vector nodes, int pos) {
    int index = -1;
    double left = 360, up = 90;
    for (int i = pos; i < nodes.size(); i++) {
      TrackRectangle tr = new TrackRectangle( (Node) nodes.get(i));
      if (tr.getLeft() < left || tr.getBottom() < up) {
        left = tr.getLeft();
        up = tr.getBottom();
        index = i;
      }
    }
    return index;
  }

  /**
   * 得到所有独立航迹的节点数据
   * 除去了两条航迹对应一条路线的航迹节点
   */
  public Node[] getAllIndependentLXNodes() {
    return this.trks;
  }

  /**
   * 得到所有两条航迹对应一条路线的对象
   */
  public TwoNode[] getTwoNode() {
    return null; //TracksShouldLink.getTwoNode();
  }

  private boolean isNearBE(Node t1, Node t2) {
    NodeList nl1 = ItemValue.getTracksPoint(t1);
    NodeList nl2 = ItemValue.getTracksPoint(t2);
    if ( (nl1 == null) || (nl2 == null)) {
      return false;
    }
    else {
      Node t1f = nl1.item(0);
      Node t1l = nl1.item(nl1.getLength() - 1);
      Node t2f = nl2.item(0);
      Node t2l = nl2.item(nl2.getLength() - 1);
      if (this.getDisOfTPoint(t1f, t2f) < TrackRectangle.NEAR_DISTANCE) {
        return true;
      }
      else if (this.getDisOfTPoint(t1f, t2l) < TrackRectangle.NEAR_DISTANCE) {
        return true;
      }
      else if (this.getDisOfTPoint(t1l, t2f) < TrackRectangle.NEAR_DISTANCE) {
        return true;
      }
      else if (this.getDisOfTPoint(t1l, t2l) < TrackRectangle.NEAR_DISTANCE) {
        return true;
      }
      return false;
    }
  }

  /**
   * 得到任何两个航迹点的距离
   */
  private double getDisOfTPoint(Node tp1, Node tp2) {
//    double tp1x = Double.parseDouble(ItemValue.getTracksPointX(tp1));
//    double tp1y = Double.parseDouble(ItemValue.getTracksPointY(tp1));
//    double tp2x = Double.parseDouble(ItemValue.getTracksPointX(tp2));
//    double tp2y = Double.parseDouble(ItemValue.getTracksPointY(tp2));
    return ItemValue.calculateDistanceBetween2Nodes1(tp1, tp2);
//    double temp = (tp1x - tp2x) * (tp1x - tp2x) + (tp1y - tp2y) * (tp1y - tp2y);
//    return Math.pow(temp, 0.5);
  }

  /**
   * 是否符合合并的条件
   * 1.行政等级不同的
   * 2.
   */
  private boolean isCanLink(Node t1, Node t2) {
    if ( (ItemValue.getTracksGrade(t1)).equals(ItemValue.getTracksGrade(t2))) {
      return true;
    }
    else {
      return false;
    }
  }

}