relatewptaftercut.java

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

package net.aetherial.gis.output.toLd.cut;

import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import org.w3c.dom.Element;
import net.aetherial.gis.surface.ItemValue;
import java.util.Vector;
import net.aetherial.gis.garmin.GarminGMLDoc;
import net.aetherial.gis.publicuse.PointLineDistance;
import net.aetherial.gis.our.auto.check.repeattrk.TrackRectangle;

/**
 * <p>Title: </p>
 *
 * <p>Description:在切割航迹之后,将航点关联至切割后的航迹 </p>
 *
 * <p>Copyright: Copyright (c) 2004</p>
 *
 * <p>Company: </p>
 *
 * @author not attributable
 * @version 1.0
 */
public class RelateWPTAfterCut {
  /**
   * 被切的航迹
   */
  private Node beCutTrk = null;

  /**
   * 新产生的航迹
   */
  private Node newTrk = null;
  /**
   * 航点在重新关联时，遇到已经关联至其他航迹的，是否重新关联到本航迹中来
   * 如果启用该功能，需先将所有航点ID致“-2”；其他航迹关联之后，再运算时，就不再关联到新航迹了。
   */
  private boolean isWaypointKeepToFormer = false;

  public RelateWPTAfterCut() {
  }

  public void relateToNewTrk(Node beCutTrk, Node newTrk) {
    this.setBeCutTrk(beCutTrk);
    this.setNewTrk(newTrk);
    this.relateToNewTrk();
  }

  public void relateToNewTrk() {

    if (this.beCutTrk == null || this.newTrk == null) {
      return;
    }
//    System.out.println("relateToNewTrk()" + ItemValue.getTracksName(this.newTrk));
    Node[] wpts = ItemValue.getTracksWaypoint(this.beCutTrk);
    Node temp = null;
    for (int i = 0; wpts != null && i < wpts.length; i++) {
      temp = this.getNearWpt(this.newTrk, wpts[i]);
      if (temp != null) {
        temp = this.copyWpt(temp);
        ItemValue.setWaypointTracksID(temp, ItemValue.getTracksID(this.newTrk));
      }
    }
  }

  public boolean relateWptToTrk(Node waypoint, Node track) {

    if (waypoint == null || track == null) {
      return false;
    }
    Node temp = this.getNearWpt(track, waypoint);
    if (temp != null) {
      temp = this.copyWpt(temp);
      ItemValue.setWaypointTracksID(temp, ItemValue.getTracksID(track));
      return true;
    }
    return false;
  }

  public void relateWptToTrk(Node[] waypoints, Node track) {
    if (waypoints == null || track == null) {
      return;
    }
    else {
      for (int i = 0; i < waypoints.length; i++) {
        relateWptToTrk(waypoints[i], track);
      }
    }
  }

  /**
   * 将航点去除重复后关联
   */
  public void relateNoRepeatToTrk(Node[] waypoints, Node track){
    waypoints = getNoRepeatWpts(waypoints);
    this.relateWptToTrk(waypoints,track);
  }

  public Node[] getNoRepeatWpts(Node[] waypoints) {
    Vector temp = new Vector();
    for (int i = 0;waypoints != null && i < waypoints.length; i++) {
      if (!isInVector(temp,waypoints[i])) {
        temp.add(waypoints[i]);
      }
    }
    Node[] t = new Node[temp.size()];
    temp.copyInto(t);
    return t;
  }
  private boolean isInVector(Vector nodes,Node waypoint){
    for (int i = 0; i < nodes.size(); i++) {
      if (this.isSameWaypoint((Node)nodes.get(i),waypoint)) {
        return true;
      }
    }
    return false;
  }
  private boolean isSameWaypoint(Node waypointA, Node waypointB) {
    if (waypointA == waypointB) {
      return true;
    }

    if ( (ItemValue.getWaypointX(waypointA).equals(ItemValue.getWaypointX(
        waypointB))) &&

        (ItemValue.getWaypointY(waypointA).equals(ItemValue.
                                                  getWaypointY(waypointB))) &&

        (ItemValue.getWaypointName(waypointA).equals(ItemValue.
        getWaypointName(waypointB))) &&

        (ItemValue.getWaypointKP(waypointA).equals(ItemValue.
        getWaypointKP(waypointB)))
        ) {
      return true;
    }else{
      return false;
    }
  }

  private Node copyWpt(Node wpt) {
    return GarminGMLDoc.addXmlWaypoint(wpt);
  }

  private Node getNearWpt(Node track, Node waypoint) {
    double distance = 0.0;
    double minDis = 0.02;
//    Node minTp = null;
    Node fp = null;
    NodeList nl = ItemValue.getTracksPoint(track);
    for (int i = 1; i < nl.getLength(); i++) {

      distance = this.getDistance(nl.item(i - 1), nl.item(i), waypoint);
      if (minDis > distance) {
        minDis = distance;
//        minTp = nl.item(i - 1);
        fp = getFootPoint(nl.item(i - 1), nl.item(i), waypoint);
      }
    }
    if (minDis == 0.02) {
//      this.print("没有发现与" + ItemValue.getWaypointName(waypoint) + "相近的点！");
    }
    else {
      if (fp != null) {
        TrackRectangle tr = new TrackRectangle(track);
        if (TrackRectangle.isPointInIt(Double.parseDouble(ItemValue.
            getWaypointX(waypoint)),
                                       Double.parseDouble(ItemValue.
            getWaypointY(waypoint)), tr)) {

          if (getDistance(fp, waypoint) < TrackRectangle.NEAR_DISTANCE * 4) {
            return waypoint;
          }
        }

      }
    }

    return null;
  }

  private double getLineToPointDis(Node pt1, Node pt2, Node wpt) {
    PointLineDistance pl = new PointLineDistance();
    pl.setPoint0(Double.parseDouble(ItemValue.getWaypointX(wpt)),
                 Double.parseDouble(ItemValue.getWaypointY(wpt)));
    pl.setPoint1(Double.parseDouble(ItemValue.getTracksPointX(pt1)),
                 Double.parseDouble(ItemValue.getTracksPointY(pt1)));
    pl.setPoint2(Double.parseDouble(ItemValue.getTracksPointX(pt2)),
                 Double.parseDouble(ItemValue.getTracksPointY(pt2)));
//    pl.getDisOfP1P2();
    return pl.getDis();
  }

  /**
   * 返回的是 新产生 的 航迹 点
   */
  private Node getFootPoint(Node begin, Node end, Node wp) {

    double bx, by, bz, ex, ey, ez, px, py, pz, fpx, fpy, fpz;
    /**
     * begin 经纬度
     */
    bx = Double.parseDouble(ItemValue.getTracksPointX(begin));
    by = Double.parseDouble(ItemValue.getTracksPointY(begin));
    bz = Double.parseDouble(ItemValue.getTracksPointZ(begin));

    /**
     * end 经纬度
     */
    ex = Double.parseDouble(ItemValue.getTracksPointX(end));
    ey = Double.parseDouble(ItemValue.getTracksPointY(end));
    ez = Double.parseDouble(ItemValue.getTracksPointZ(end));

    /**
     * 航点 经纬度
     */
    px = Double.parseDouble(ItemValue.getWaypointX(wp));
    py = Double.parseDouble(ItemValue.getWaypointY(wp));
    pz = Double.parseDouble(ItemValue.getWaypointZ(wp));

    double k = (ey - by) / (ex - bx);

    fpx = (k * k * bx + k * (py - by) + px) / (k * k + 1);
    fpy = k * (fpx - bx) + by;

    if (bz - ez > 0.00001) {
      double k1 = (ey - by) / (ez - bz);
      fpz = (k1 * k1 * bz + k1 * (py - by) + pz) / (k1 * k1 + 1);
    }
    else {
      fpz = bz;
    }
    double minx = Math.min(bx, ex);
    double miny = Math.min(by, ey);
    double minz = Math.min(bz, ez);
    double maxx = Math.max(bx, ex);
    double maxy = Math.max(by, ey);
    double maxz = Math.max(bz, ez);

    Node fp = ItemValue.getNewTrackPoint("" + fpx, "" + fpy, "" + fpz, "");
    if (minx < fpx && fpx < maxx && miny < fpy && fpy < maxy) { // && minz<fpz && fpz<maxz){
      return fp;
    }
    if (getDistance(begin, wp) < getDistance(end, wp)) {
      return begin;
    }
    else {
      return end;
    }
  }

  private double getDistance(Node begin, Node end, Node wp) {
//    return this.getLineToPointDis(begin,end,wp);
    return getDistance(getFootPoint(begin, end, wp), wp);

  }

  private double getDistance(Node tp, Node wp) {
    double tpx = Double.parseDouble(ItemValue.getTracksPointX(tp));
    double tpy = Double.parseDouble(ItemValue.getTracksPointY(tp));
    double wpx = Double.parseDouble(ItemValue.getWaypointX(wp));
    double wpy = Double.parseDouble(ItemValue.getWaypointY(wp));
    return Math.sqrt( (tpx - wpx) * (tpx - wpx) + (tpy - wpy) * (tpy - wpy));
  }

  private void print(String string) {
    System.out.println(string);
  }

  public void setBeCutTrk(Node beCutTrk) {
    this.beCutTrk = beCutTrk;
  }

  public void setNewTrk(Node newTrk) {
    this.newTrk = newTrk;
  }

  public void setIsWaypointKeepToFormer(boolean isWaypointKeepToFormer) {
    this.isWaypointKeepToFormer = isWaypointKeepToFormer;
  }
}