createnewtp.java

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

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

import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import net.aetherial.gis.surface.ItemValue;

/**
 * <p>Title: </p>
 *
 * <p>Description: </p>
 *
 * <p>Copyright: Copyright (c) 2004</p>
 *
 * <p>Company: </p>
 *
 * @author not attributable
 * @version 1.0
 */
public class CreateNewTP {
  public CreateNewTP() {
  }

  private Node[] getNearstFirstPoint(Node trackPoint, Node track) {
    if (track == null || trackPoint == null) {
      return null;
    }
    NodeList nl = ItemValue.getTracksPoint(track);
    if (nl == null) {
      return null;
    }
    double minDis = 10000000.0;
    for (int i = 0; i < nl.getLength() - 1; i++) {
      minDis = Math.min(minDis,
                        this.getDistance_ByTp(nl.item(i), nl.item(i + 1), trackPoint));
    }
    for (int i = 0; i < nl.getLength() - 1; i++) {
      if (minDis ==
          this.getDistance_ByTp(nl.item(i), nl.item(i + 1), trackPoint)) {
        Node[] temp = new Node[2];
        temp[0] = nl.item(i);
        temp[1] = nl.item(i + 1);
        return temp;
      }
    }
    return null;
  }

  private boolean isTrackPointInTrack(Node trackPoint, Node track) {
    if (track == null || trackPoint == null) {
      return false;
    }
    NodeList nl = ItemValue.getTracksPoint(track);
    if (nl == null) {
      return false;
    }
    for (int i = 0; i < nl.getLength(); i++) {
      if (trackPoint == nl.item(i)) {
        return true;
      }
    }
    return false;
  }

  public Node createNewFootPoint(Node trackPoint, Node track) {
    try {
      Node[] t2 = getNearstFirstPoint(trackPoint, track);
      if (t2 == null) {
        return null;
      }
      Node temp = this.getFootPoint_Wag(t2[0], t2[1], trackPoint);
      if (temp == null) {
        return null;
      }
      if (isTrackPointInTrack(temp,track)) {
        return temp;
      }else{
        return ItemValue.insertNewTrackPoint(track, t2[1],
                                             ItemValue.getTracksPointX(temp),
                                             ItemValue.getTracksPointY(temp),
                                             ItemValue.getTracksPointZ(temp));
      }
    }
    catch (Exception ex) {
      System.out.println(this.getClass().getName() + " Err:" + ex.getMessage());
      return null;
    }
  }

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

    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.getTracksPointX(trackPoint));
    py = Double.parseDouble(ItemValue.getTracksPointY(trackPoint));
    pz = Double.parseDouble(ItemValue.getTracksPointZ(trackPoint));

    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, "");
//    Node fp = ItemValue.insertNewTrackPoint(ItemValue.getTrackPoint_Track(end),end, "" + fpx, "" + fpy, "" + fpz);
    if (minx < fpx && fpx < maxx && miny < fpy && fpy < maxy) { // && minz<fpz && fpz<maxz){
      return fp;
    }
    if (getDistance_ByTp(begin, trackPoint) < getDistance_ByTp(end, trackPoint)) {
      return begin;
    }
    else {
      return end;
    }
  }

  private double getDistance_ByTp(Node begin, Node end, Node tp) {
    return getDistance_ByTp(getFootPoint_Wag(begin, end, tp), tp);

  }

  private double getDistance_ByTp(Node tp1, Node tp2) {
    double tpx = Double.parseDouble(ItemValue.getTracksPointX(tp1));
    double tpy = Double.parseDouble(ItemValue.getTracksPointY(tp1));
    double wpx = Double.parseDouble(ItemValue.getTracksPointX(tp2));
    double wpy = Double.parseDouble(ItemValue.getTracksPointY(tp2));
    return Math.sqrt( (tpx - wpx) * (tpx - wpx) + (tpy - wpy) * (tpy - wpy));
  }

  public static void main(String[] args) {
    CreateNewTP createnewtp = new CreateNewTP();
  }
}