/**
   * look through the list of coordinate, and see if any are contained within the currently visible
   * area
   */
  private boolean isVisible(
      final LatLonPoint tl, final LatLonPoint br, final CoordFloatString coords) {
    boolean res = false;
    final MWC.GenericData.WorldLocation _tl =
        new MWC.GenericData.WorldLocation(tl.getLatitude(), tl.getLongitude(), 0);
    final MWC.GenericData.WorldLocation _br =
        new MWC.GenericData.WorldLocation(br.getLatitude(), br.getLongitude(), 0);
    final MWC.GenericData.WorldArea area = new MWC.GenericData.WorldArea(_tl, _br);
    area.normalise();

    for (int i = 0; i < coords.maxIndex(); i++) {
      final float x = coords.getXasFloat(i);
      final float y = coords.getYasFloat(i);

      _workingLocation.setLat(y);
      _workingLocation.setLong(x);

      if (area.contains(_workingLocation)) {
        res = true;
        continue;
      }
    }

    return res;
  }
  private boolean overlaps(
      final LatLonPoint tl, final LatLonPoint br, final CoordFloatString coords) {
    boolean res = false;
    float maxLat = 0, minLat = 0, maxLong = 0, minLong = 0;
    boolean first = true;

    // create our area of interest
    _workingArea.getTopLeft().setLat(tl.getLatitude());
    _workingArea.getTopLeft().setLong(tl.getLongitude());
    _workingArea.getBottomRight().setLat(br.getLatitude());
    _workingArea.getBottomRight().setLong(br.getLongitude());

    // build up the area of the coords
    final int len = Math.abs(coords.maxIndex());

    for (int i = 0; i < len; i++) {
      // retrieve the x and y values
      final float x = coords.getXasFloat(i);
      final float y = coords.getYasFloat(i);

      // initialise our values if this is the first pass
      if (first) {
        first = false;
        maxLat = minLat = y;
        maxLong = minLong = x;
      } else {
        // else update our extreme values
        minLat = Math.min(minLat, y);
        maxLat = Math.max(maxLat, y);

        minLong = Math.min(minLong, x);
        maxLong = Math.max(maxLong, x);
      }
    }

    // put our limits into the area of this line
    _otherWorkingArea.getTopLeft().setLat(maxLat);
    _otherWorkingArea.getTopLeft().setLong(minLong);
    _otherWorkingArea.getBottomRight().setLat(minLat);
    _otherWorkingArea.getBottomRight().setLong(maxLong);

    // so, we've now got our two areas, see if they overlap
    res = _workingArea.overlaps(_otherWorkingArea);

    // well done!
    return res;
  }
示例#3
0
  /**
   * Convert to a geocentric frame using a LatLonPoint.
   *
   * @param llpt
   * @return a vector of ecef values
   */
  public double[] toGeocentricFrame(LatLonPoint llpt) {
    // All calculations are done using radians!
    double ecef[] = new double[3];
    double ned[] = new double[3];
    double lat_ = (double) llpt.getLatitude();
    double lon_ = (double) llpt.getLongitude();
    double latitude = ProjMath.degToRad(lat_);
    double longitude = ProjMath.degToRad(lon_);

    ned2ecef(ned, latitude, longitude, ecef);

    return ecef;
  }
  /**
   * set lat and lon by using UTM coordinates
   *
   * @param strZone UTM-zone, e.g. 32U
   * @param strNorthing Northing component
   * @param strEasting Easting component
   */
  public void set(String strZone, String strNorthing, String strEasting) {
    LatLonPoint ll = new LatLonPoint();

    utm.zone_letter = strZone.charAt(strZone.length() - 1);
    utm.zone_number = Convert.toInt(strZone.substring(0, strZone.length() - 1));
    utm.northing = (float) Common.parseDouble(strNorthing);
    utm.easting = (float) Common.parseDouble(strEasting);

    ll = utm.toLatLonPoint(); // returns null if unvalit UTM-coordinates
    if (ll != null) {
      this.utmValid = true;
      this.latDec = ll.getLatitude();
      this.lonDec = ll.getLongitude();
    } else {
      this.latDec = 91;
      this.lonDec = 361;
    }
  }
示例#5
0
  /**
   * Construct a NedFrame from a ECEF vector and a LatLonPoint.
   *
   * @param ecefVector
   */
  public NedFrame(double[] ecefVector, LatLonPoint llpt) {
    // All calculations are done using radians!

    double ecef[] = new double[3];
    double ned[] = new double[3];
    double lat_ = (double) llpt.getLatitude();
    double lon_ = (double) llpt.getLongitude();
    double latitude = ProjMath.degToRad(lat_);
    double longitude = ProjMath.degToRad(lon_);

    ecef[0] = ecefVector[0];
    ecef[1] = ecefVector[1];
    ecef[2] = ecefVector[2];

    ecef2ned(ned, latitude, longitude, ecef);

    this.x = (float) ned[0];
    this.y = (float) ned[1];
    this.z = (float) ned[2];
  }
 /**
  * Create CWPoint by using a LatLonPoint
  *
  * @param CWPoint LatLonPoint
  */
 public CWPoint(LatLonPoint llPoint) {
   super(llPoint.getLatitude(), llPoint.getLongitude());
   this.utmValid = false;
 }
 /**
  * Set CWPoint by using a LatLonPoint
  *
  * @param CWPoint LatLonPoint
  */
 public void set(LatLonPoint llPoint) {
   this.latDec = llPoint.getLatitude();
   this.lonDec = llPoint.getLongitude();
   this.utmValid = false;
 }
示例#8
0
 /**
  * Create a OMEllipse, positioned with a lat-lon center and x-y axis. Rendertype is
  * RENDERTYPE_OFFSET.
  *
  * @param centerPoint latitude/longitude of center point, decimal degrees
  * @param w horizontal diameter of circle/ellipse, pixels
  * @param h vertical diameter of circle/ellipse, pixels
  * @param rotateAngle angle of rotation in Radians
  */
 public OMEllipse(LatLonPoint centerPoint, int w, int h, double rotateAngle) {
   // Use circle constructor
   super(centerPoint.getLatitude(), centerPoint.getLongitude(), 0, 0, w, h);
   setRotationAngle(rotateAngle);
 }
示例#9
0
 /**
  * Create a OMEllipse, positioned at a Lat-lon location, x-y offset, x-y axis. Rendertype is
  * RENDERTYPE_OFFSET.
  *
  * @param centerPoint latitude/longitude of center point, decimal degrees
  * @param offset_x1 # pixels to the right the center will be moved from lonPoint.
  * @param offset_y1 # pixels down that the center will be moved from latPoint.
  * @param w horizontal diameter of circle/ellipse, pixels.
  * @param h vertical diameter of circle/ellipse, pixels.
  */
 public OMEllipse(
     LatLonPoint centerPoint, int offset_x1, int offset_y1, int w, int h, double rotateAngle) {
   super(centerPoint.getLatitude(), centerPoint.getLongitude(), offset_x1, offset_y1, w, h);
   setRotationAngle(rotateAngle);
 }