entirelyrepeate.java

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

package net.aetherial.gis.our.auto.check.repeattrk;

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

/**
 * <p>Title: </p>
 *
 * <p>Description:  判断航迹的完全重复情况</p>
 *
 * <p>Copyright: Copyright (c) 2004</p>
 *
 * <p>Company: </p>
 *
 * @author not attributable
 * @version 1.0
 */
public class EntirelyRepeate {
  private Hashtable hash = null;
  private String n = "";
  public EntirelyRepeate() {
  }

  public void setHash(Hashtable hash) {
    this.hash = hash;
  }

  private void println(String message) {
    System.out.println(message);
    n = n + message + "\r\n";
  }

  public String getAndResetResult() {
    String temp = n;
    n = "";
    return temp;
  }

  public boolean checkRepeatTrk() {
    Node[] trks = ItemValue.getTracks();
    if (trks == null) {
      return false;
    }
    else {
      boolean isFindRepeate = false;
      for (int i = 0; i < trks.length; i++) {
        System.out.println("正在检查" + ItemValue.getTracksName(trks[i]));
        for (int j = (i + 1); j < trks.length; j++) {
          if (isTrkEntirelyEquals(trks[i], trks[j])) {
            if (this.hash != null) {

              println(this.hash.get(i + "") + ":[" +
                      ItemValue.getTracksName(trks[i]) +
                      "] 与 " + this.hash.get(j + "") + ":[" +
                      ItemValue.getTracksName(trks[j]) + "整条完全重复!");
            }
            else {
              println("第" + (i + 1) + "条航迹:[" + ItemValue.getTracksName(trks[i]) +
                      "] 与 第" + (j + 1) + "条航迹:[" +
                      ItemValue.getTracksName(trks[j]) + "整条完全重复!");
            }
            isFindRepeate = true;
          }
          else if (isTrkPartEquals(trks[i], trks[j])) {
//          else if (compareWithEveryLine(trks[i], trks[j])) {
            if (this.hash != null) {
              println(this.hash.get(i + "") + ":[" +
                      ItemValue.getTracksName(trks[i]) +
                      "] 与 " + this.hash.get(j + "") + ":[" +
                      ItemValue.getTracksName(trks[j]) + "部分完全重复!");
            }
            else {
              println("第" + (i + 1) + "条航迹:[" + ItemValue.getTracksName(trks[i]) +
                    "] 与 第" + (j + 1) + "条航迹:[" +
                    ItemValue.getTracksName(trks[j]) + "部分完全重复!");
            }

            isFindRepeate = true;
          }
        }
      }
      return isFindRepeate;
    }
  }

  /**
   * 判断两条航迹是否完全相同
   */
  private boolean isTrkEntirelyEquals(Node trk1, Node trk2) {
    NodeList nl1 = ItemValue.getTracksPoint(trk1);
    NodeList nl2 = ItemValue.getTracksPoint(trk2);

    if ( (nl1 == null) || (nl2 == null)) {
      return false;
    }
    if (nl1.getLength() == nl2.getLength()) {
      boolean equals_temp = true;
      for (int i = 0; i < nl1.getLength(); i++) {
        if (! (isEquals(nl1.item(i), nl2.item(i)))) {
          equals_temp = false;
          break;
        }
      }
      if (equals_temp == true) {
        return true;
      }
    }
    return false;
  }

  /**
   * 判断两条航迹是否是部分相同,这个方法找出的错误是属于严重性的切割错误
   */
  private boolean isTrkPartEquals(Node trk1, Node trk2) {
    TrackRectangle tr1 = new TrackRectangle(trk1);
    TrackRectangle tr2 = new TrackRectangle(trk2);
    if (!(tr1.isIntersect(tr2))) {
      return false;
    }

    NodeList nl1 = ItemValue.getTracksPoint(trk1);
    NodeList nl2 = ItemValue.getTracksPoint(trk2);

    if ( (nl1 == null) || (nl2 == null)) {
      return false;
    }

    Node[] source = null, equalsMent = null, temp = null;
    if (nl1.getLength() > nl2.getLength()) {
      source = this.turn_NodeLsit_To_Nodes(nl1);
      equalsMent = this.turn_NodeLsit_To_Nodes(nl2);
    }
    else {
      equalsMent = this.turn_NodeLsit_To_Nodes(nl1);
      source = this.turn_NodeLsit_To_Nodes(nl2);
    }

    equalsMent = this.getRidOfBE(equalsMent);
    if (equalsMent == null) {
      return false;
    }
    int diff = source.length - equalsMent.length;

    for (int i = 0; i <= diff; i++) {
      temp = this.subNodeArray(source, i, (i + equalsMent.length));
//      System.out.println("从第"+ (i+1) + "位置开始");
      if (this.isPointsEntirelyEquals(temp, equalsMent)) {
        return true;
      }
    }
    return false;
  }

  /**
   * 每条线断,每条线断的比较,这样会找出很多只有一点点重复的航迹.包括严重性错误.
   */
  private boolean compareWithEveryLine(Node trk1, Node trk2){
    TrackRectangle tr1 = new TrackRectangle(trk1);
    TrackRectangle tr2 = new TrackRectangle(trk2);
    if (!(tr1.isIntersect(tr2))) {
      return false;
    }
    NodeList nl1 = ItemValue.getTracksPoint(trk1);
    NodeList nl2 = ItemValue.getTracksPoint(trk2);

    if ( (nl1 == null) || (nl2 == null)) {
      return false;
    }

    Node[] source = null, equalsMent = null, temp = null,everyLine = new Node[2];
    if (nl1.getLength() > nl2.getLength()) {
      source = this.turn_NodeLsit_To_Nodes(nl1);
      equalsMent = this.turn_NodeLsit_To_Nodes(nl2);
    }
    else {
      equalsMent = this.turn_NodeLsit_To_Nodes(nl1);
      source = this.turn_NodeLsit_To_Nodes(nl2);
    }

    //equalsMent = this.getRidOfBE(equalsMent);
    if ((equalsMent == null)||(source == null)) {
      return false;
    }
    int diff = -1;
    for (int i = 0; i < equalsMent.length-1; i++) {
      everyLine[0] = equalsMent[i];
      everyLine[1] = equalsMent[i+1];

      diff = source.length - 2;
      for (int j = 0; j <= diff; j++) {
        temp = this.subNodeArray(source, j, (j + 2));
        if (this.isPointsEntirelyEquals(temp, everyLine)) {
          return true;
        }
      }
    }
    return false;
  }

  /**
   * 按长度分割数组
   */
  private Node[] subNodeArray(Node[] array, int a, int b) {
    Node[] temp = new Node[b - a];
    for (int i = a; i < b; i++) {
      temp[i - a] = array[i];
    }
    return temp;
  }

  /**
   * 去处掉数组的首尾
   * 如果数组的长度小于3,直接返回null,因为构成不了一条直线;
   */
  private Node[] getRidOfBE(Node[] points){
    if (points.length < 3) {
      return null;
    }
    Node[] temp = new Node[points.length-2];
    for (int i = 0; i < temp.length; i++) {
      temp[i] = points[i+1];
    }
    return temp;
  }

  /**
   * 将NodeList 格式转换成Node[]格式
   */
  private Node[] turn_NodeLsit_To_Nodes(NodeList nl) {
    if (nl == null) {
      return null;
    }
    Node[] temp = new Node[nl.getLength()];
    for (int i = 0; i < temp.length; i++) {
      temp[i] = nl.item(i);
    }
    return temp;
  }

  /**
   * 航迹点是否完全相同
   */
  private boolean isPointsEntirelyEquals(Node[] p1, Node[] p2) {
    if ( (p1 == null) || (p2 == null)) {
      return false;
    }

    if (p1.length != p2.length) {
      System.err.println("截取航迹的长度不对!");
//      this.println("截取航迹的长度不对!");
      return false;
    }
//    System.out.println("p1.length = " + p1.length + ",p2.length = " + p2.length);
    boolean isPass = true;
    /**
     * 顺着检测一下
     */
    for (int i = 0; i < p1.length; i++) {
      if (! (isEquals(p1[i], p2[i]))) {
//        System.out.println("顺着检测一下,不通过.在位置:" + i);
        isPass = false;
        break;
      }
    }
    if (isPass) {
      System.out.println("找到部分相同的航迹!在顺着检测.");
      return true;
    }
    /**
     * 反着检测一下
     */

    for (int i = 0; i < p1.length; i++) {
      if (! (isEquals(p1[i], p2[p1.length - i -1]))) {
//        System.out.println("反着检测一下,不通过.在位置:" + i);
        return false;
      }
    }
    System.out.println("找到部分相同的航迹!在反着检测.");
    return true;
  }

  /**
   * 比较两个航迹点是否位置相同
   */
  private boolean isEquals(Node p1, Node p2) {
    double p1_x = ItemValue.getRound(Double.parseDouble(ItemValue.
        getTracksPointX(p1)), 5);
    double p1_y = ItemValue.getRound(Double.parseDouble(ItemValue.
        getTracksPointY(p1)), 5);
    double p1_z = ItemValue.getRound(Double.parseDouble(ItemValue.
        getTracksPointZ(p1)), 5);
    double p2_x = ItemValue.getRound(Double.parseDouble(ItemValue.
        getTracksPointX(p2)), 5);
    double p2_y = ItemValue.getRound(Double.parseDouble(ItemValue.
        getTracksPointY(p2)), 5);
    double p2_z = ItemValue.getRound(Double.parseDouble(ItemValue.
        getTracksPointZ(p2)), 5);

    if ( (p1_x == p2_x) && (p1_y == p2_y) && (p1_z == p2_z)) {
      return true;
    }
    else {
      return false;
    }
  }

}