concatenatedtrack.java

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

package net.aetherial.gis.publicuse.track;

import org.w3c.dom.Node;
import java.util.Vector;
import net.aetherial.gis.surface.ItemValue;
import org.w3c.dom.NodeList;
import net.aetherial.gis.our.FrameOur;
import net.aetherial.gis.garmin.GarminGMLDoc;
import org.w3c.dom.Element;

/**
 * <p>Title: </p>
 *
 * <p>Description:连续的航迹，串联形成的航迹 </p>
 *
 * <p>Copyright: Copyright (c) 2004</p>
 *
 * <p>Company: </p>
 *
 * @author not attributable
 * @version 1.0
 */
public class ConcatenatedTrack {
  private Vector concatTrack = new Vector();
  private static boolean isInosculate = false;
  public ConcatenatedTrack() {
  }

  private static void printVecotr(Vector concatenated) {
    System.out.println("  PrintVecotr===================lentgh:" +
                       concatenated.size());
    for (int i = 0; i < concatenated.size(); i++) {
      System.out.println("      " + (ConcatenatedTrack) concatenated.get(i));
    }
    System.out.println("    ===================");
    System.out.println("");
  }

  public Vector getTrackPoints() {
    Vector tps = new Vector();
    NodeList nl;
    for (int i = 0; i < concatTrack.size(); i++) {
      nl = ItemValue.getTracksPoint( (Node) concatTrack.get(i));
      if (nl != null) {
        for (int j = 0; j < nl.getLength(); j++) {
          tps.add(nl.item(j));
        }
      }
    }
    return tps;
  }

  public String getGrade() {

    String grade;
    for (int i = 0; i < concatTrack.size(); i++) {
      grade = ItemValue.getTracksGrade((Node) concatTrack.get(i));
      if ((!grade.endsWith("")) || (!grade.equals("null"))) {
        return grade;
      }

    }
    return "";
  }


  public static Vector addTracks(Vector vtrks) {
    Vector cts = new Vector();
    if (vtrks != null) {
      ConcatenatedTrack ct = null;
      boolean added = false;
      ct = new ConcatenatedTrack();
      while (vtrks.size() > 0) {
        for (int i = 0; i < vtrks.size(); i++) {
//          System.out.println("    ct.addAConcatenatedTrack"+i);
          if (ct.addAConcatenatedTrack( (Node) vtrks.get(i))) {
            added = true;
            vtrks.remove(i);
            i--;

          }
        }
        if (vtrks.size() == 0) {
          cts.add(ct);
//          System.out.println("    println ct" + ct);
        }

        if (added == false) {
          cts.add(ct);
//          System.out.println("    println ct" + ct);
          ct = new ConcatenatedTrack();
        }

        added = false;
      }
//      ConcatenatedTrack.printVecotr(cts);
    }
    return cts;

  }

  public static Vector addTracks(Node[] trks) {
    if (trks != null) {
      Vector vtrks = new Vector();
      for (int i = 0; i < trks.length; i++) {
        vtrks.add(trks[i]);
      }
      return addTracks(vtrks);
    }
    else {
      return new Vector();
    }
//    Vector cts = new Vector();
//    if (trks != null) {
//      ConcatenatedTrack ct = null;
//      Vector vtrks = new Vector();
//      for (int i = 0; i < trks.length; i++) {
//        vtrks.add(trks[i]);
//      }
//      boolean added = false;
//      ct = new ConcatenatedTrack();
//      while (vtrks.size() > 0) {
//        for (int i = 0; i < vtrks.size(); i++) {
////          System.out.println("    ct.addAConcatenatedTrack"+i);
//          if (ct.addAConcatenatedTrack( (Node) vtrks.get(i))) {
//            added = true;
//            vtrks.remove(i);
//            i--;
//
//          }
//        }
//        if (vtrks.size() == 0) {
//          cts.add(ct);
////          System.out.println("    println ct" + ct);
//        }
//
//        if (added == false) {
//          cts.add(ct);
////          System.out.println("    println ct" + ct);
//          ct = new ConcatenatedTrack();
//        }
//
//        added = false;
//      }
////      ConcatenatedTrack.printVecotr(cts);
//    }
//    return cts;
  }

  public boolean addAConcatenatedTrack(Node track) {
    if (track == null) {
      return false;
    }
    else if (this.concatTrack.size() == 0) {
      this.concatTrack.add(track);
      return true;
    }
    else {
      NodeList nl = ItemValue.getTracksPoint(track);
      Node tp1b = this.getFirstTrackPoint();
      Node tp1e = this.getLastTrackPoint();
      if (tp1b == null || tp1e == null || nl == null) {
        return false;
      }
      else {
        Node tp2b = nl.item(0);
        Node tp2e = nl.item(nl.getLength() - 1);
        if (this.isLink(tp1b, tp2b)) {
          this.reverse(track);
          this.concatTrack.add(0, track);
          return true;
        }
        else if (this.isLink(tp1b, tp2e)) {
          this.concatTrack.add(0, track);
          return true;
        }
        else if (this.isLink(tp1e, tp2b)) {
          this.concatTrack.add(track);
          return true;
        }
        else if (this.isLink(tp1e, tp2e)) {
          this.reverse(track);
          this.concatTrack.add(track);
          return true;
        }
        else {
          return false;
        }
      }
    }

  }

  public Node createNewTrack() {
    Vector ve = this.getTrackPoints();
    if (ve.size() == 0) {
      return null;
    }
    else {
//      GarminGMLDoc.ad
      Element e = GarminGMLDoc.addTrack("NewTrack",
                                        (Node)this.concatTrack.get(0));
      for (int i = 0; i < ve.size(); i++) {
        GarminGMLDoc.addTrackPoint(e, (Node) ve.get(i));
      }
      return e.getParentNode();
    }

  }

  /**
   * 得到有信息的航迹节点
   */
  private Node getUseFulNode() {
    Node temp = null;
    for (int i = 0; i < this.concatTrack.size(); i++) {
      if ( ( (Node)this.concatTrack.get(i)) != null) {
        temp = (Node)this.concatTrack.get(i);
        break;
      }
    }
    return temp;
  }

  public Node[] getConcatenatedTrack() {
    if (this.concatTrack.size() == 0) {
      return new Node[0];
    }
    Node[] temp = new Node[this.concatTrack.size()];
    this.concatTrack.copyInto(temp);
    return temp;
  }

  public String getConcatenatedName() {
    if (this.concatTrack.size() == 0) {
      return "";
    }
    else {
      String n = "";
      for (int i = 0; i < this.concatTrack.size(); i++) {
        n = n + ItemValue.getTracksName( (Node)this.concatTrack.get(i));
        if (i != this.concatTrack.size() - 1) {
          n = n + " || ";
        }
        else {
          n = n + ".";
        }
      }
      return n;
    }
  }

  public Vector getConcatenatedVectorTrack() {
    return this.concatTrack;
  }

  public Node getFirstTrack(){
    return (Node)this.concatTrack.get(0);
  }

  public Node getLastTrack(){
    return (Node)this.concatTrack.get(concatTrack.size()-1);
  }


  public Node get(int i) {
    try {
      return (Node)this.concatTrack.get(i);
    }
    catch (Exception ex) {
      return null;
    }
  }

  public int containTracksNum() {
    return this.concatTrack.size();
  }

  public Node getFirstTrackPoint() {
    if (this.concatTrack.size() == 0) {
      return null;
    }
    else {
      NodeList nl = ItemValue.getTracksPoint( (Node)this.concatTrack.get(0));
      return nl.item(0);
    }
  }

  public Node getLastTrackPoint() {
    if (this.concatTrack.size() == 0) {
      return null;
    }
    else {
      NodeList nl = ItemValue.getTracksPoint( (Node)this.concatTrack.get(this.
          concatTrack.size() - 1));
      return nl.item(nl.getLength() - 1);
    }
  }

  private boolean isLink(Node trackPoint1, Node trackPoint2) {
    String p1x = ItemValue.getTracksPointX(trackPoint1);
    String p1y = ItemValue.getTracksPointY(trackPoint1);
    String p2x = ItemValue.getTracksPointX(trackPoint2);
    String p2y = ItemValue.getTracksPointY(trackPoint2);
    if (this.isInosculate) {
      if (p1x.equals(p2x) && p1y.equals(p2y)) {
        return true;
      }
      else {
        return false;
      }
    }
    else {
      double dis = ItemValue.calculateDistanceBetween2Nodes1(trackPoint1,
          trackPoint2);
      if (dis < 80) {
        return true;
      }
      else {
        return false;
      }
    }
  }

  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));
    }
    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;
  }

  public void reverse(){
    Node trk =null;
    for (int i = 0; i < this.concatTrack.size(); i++) {
      trk = (Node)this.concatTrack.get(i);
      this.reverse(trk);
    }

    Vector temp =new Vector();
    for (int i = 0; i < this.concatTrack.size(); i++) {
      trk = (Node)this.concatTrack.get(i);
      temp.add(0,trk);
    }
    this.concatTrack = temp;
  }

  public String toString() {
    String n = "";
    n = n + "Class ConcatenatedTrack: length = " + this.containTracksNum();
    for (int i = 0; i < this.containTracksNum(); i++) {
      n = n + ", trk[" + i + "] = " +
          ItemValue.getTracksName( (Node)this.concatTrack.get(i));
    }
    n = n + ".";
    return n;
  }

  public static void main(String args[]) {
    ConcatenatedTrack.setIsInosculate(true);
    String file = "D:\\数据备份\\报部数据\\安徽省\\安庆市\\枞阳县\\整理完毕\\县\\X029.gps";
    FrameOur fo = new FrameOur();
    fo.openFile(new java.io.File(file));
    Node[] trks = ItemValue.getTracks();
    Vector ve = ConcatenatedTrack.addTracks(trks);
    ConcatenatedTrack.printVecotr(ve);
    fo.reset();

    file = "D:\\数据备份\\报部数据\\安徽省\\安庆市\\枞阳县\\整理完毕\\县\\X030.gps";
    fo.openFile(new java.io.File(file));
    trks = ItemValue.getTracks();
    ve = ConcatenatedTrack.addTracks(trks);
    ConcatenatedTrack.printVecotr(ve);
    fo.reset();

    fo.dispose();
    System.exit(0);
  }

  public static void setIsInosculate(boolean isInosculate) {
    ConcatenatedTrack.isInosculate = isInosculate;
  }
}