예제 #1
0
 /**
  * Check if equator is visible on screen.
  *
  * @return boolean
  */
 public boolean overEquator() {
   LatLonPoint llN = new LatLonPoint.Float();
   inverse(width / 2, 0, llN);
   LatLonPoint llS = new LatLonPoint.Float();
   inverse(width / 2, height, llS);
   return MoreMath.sign(llN.getY()) != MoreMath.sign(llS.getY());
 }
예제 #2
0
 public boolean determineLocation(MouseEvent e) {
   Projection projection = getProjection();
   if (cache != null && projection != null) {
     LatLonPoint ll = projection.inverse(e.getX(), e.getY(), new LatLonPoint.Double());
     location = new DTEDLocation(e.getX(), e.getY());
     location.setElevation(cache.getElevation((float) ll.getY(), (float) ll.getX()));
     location.generate(projection);
     repaint();
     return true;
   }
   return false;
 }
예제 #3
0
  /**
   * Add a point at a certain point in the polygon coordinate list. If the position is less than
   * zero, the point will be the starting point. If the position is greater than the list of current
   * points, the point will be added to the end of the poly. This method is convenient because it
   * lets you define the GrabPoint object to use for the node, in case you need a special type of
   * GrabPoint.
   *
   * @return the index for the point in the polygon, starting with 0.
   */
  public int addPoint(GrabPoint gp, int position) {

    if (gp == null) {
      return -1;
    }

    int x = gp.getX();
    int y = gp.getY();

    int renderType = poly.getRenderType();
    boolean rads = (poly.getUnits() == OMGraphic.RADIANS);

    if (renderType == OMGraphic.RENDERTYPE_LATLON) {
      Debug.message("eomg", "EditableOMPoly: adding point to lat/lon poly");

      if (projection != null) {

        double[] ll = poly.getLatLonArray();
        int actualPosition = (position == Integer.MAX_VALUE ? ll.length : position * 2);

        LatLonPoint llpnt = projection.inverse(x, y, new LatLonPoint.Double());

        if (Debug.debugging("eomp")) {
          Debug.output(
              "EditableOMPoly: adding point to lat/lon poly at "
                  + x
                  + ", "
                  + y
                  + ": "
                  + llpnt
                  + ", at the end of ");

          for (int j = 0; j < ll.length; j += 2) {
            Debug.output(ll[j] + ", " + ll[j + 1]);
          }
        }

        double[] newll = new double[ll.length + 2];

        double newlat;
        double newlon;

        if (rads) {
          newlat = llpnt.getRadLat();
          newlon = llpnt.getRadLon();
        } else {
          newlat = llpnt.getY();
          newlon = llpnt.getX();
        }

        if (actualPosition >= ll.length) {
          // Put the new points at the end
          if (ll.length != 0) {
            System.arraycopy(ll, 0, newll, 0, ll.length);
          }

          newll[ll.length] = newlat;
          newll[ll.length + 1] = newlon;

          position = ll.length / 2;

        } else if (actualPosition <= 0) {
          // Put the new point at the beginning
          System.arraycopy(ll, 0, newll, 2, ll.length);
          newll[0] = newlat;
          newll[1] = newlon;
          position = 0;
        } else {
          // actualPosition because there are 2 floats for
          // every
          // position.
          newll[actualPosition] = newlat;
          newll[actualPosition + 1] = newlon;
          System.arraycopy(ll, 0, newll, 0, actualPosition);
          System.arraycopy(
              ll, actualPosition, newll, actualPosition + 2, ll.length - actualPosition);
        }
        poly.setLocation((double[]) newll, poly.getUnits());
      }
    } else if (renderType == OMGraphic.RENDERTYPE_XY) {
      // Grab the projected endpoints
      Debug.message("eomg", "EditableOMPoly: adding point to x/y poly");
      int currentLength = poly.xs.length;
      int[] newxs = new int[currentLength + 1];
      int[] newys = new int[currentLength + 1];

      if (position >= currentLength) {
        // Put the new points at the end
        System.arraycopy(poly.xs, 0, newxs, 0, currentLength);
        System.arraycopy(poly.ys, 0, newys, 0, currentLength);
        newxs[currentLength] = x;
        newys[currentLength] = y;

        position = currentLength;

      } else if (position <= 0) {
        // Put the new points at the beginning
        System.arraycopy(poly.xs, 0, newxs, 1, currentLength);
        System.arraycopy(poly.ys, 0, newys, 1, currentLength);
        newxs[0] = x;
        newys[0] = y;

        position = 0;

      } else {
        newxs[position] = x;
        newys[position] = y;

        System.arraycopy(poly.xs, 0, newxs, 0, position);
        System.arraycopy(poly.xs, position, newxs, position + 1, currentLength - position);

        System.arraycopy(poly.ys, 0, newys, 0, position);
        System.arraycopy(poly.ys, position, newys, position + 1, currentLength - position);
      }

      poly.setLocation(newxs, newys);

    } else {
      // Rendertype is offset...
      // Grab the projected endpoints
      Debug.message("eomg", "EditableOMPoly: adding point to offset poly");
      int currentLength = poly.xs.length;
      int[] newxs = new int[currentLength + 1];
      int[] newys = new int[currentLength + 1];

      if (position >= currentLength) {
        // Put the new points at the end
        position = currentLength;

        System.arraycopy(poly.xs, 0, newxs, 0, currentLength);
        System.arraycopy(poly.ys, 0, newys, 0, currentLength);

      } else if (position <= 0) {
        // Put the new points at the beginning
        position = 0;

        System.arraycopy(poly.xs, 0, newxs, 1, currentLength);
        System.arraycopy(poly.ys, 0, newys, 1, currentLength);

      } else {

        System.arraycopy(poly.xs, 0, newxs, 0, position);
        System.arraycopy(poly.xs, position, newxs, position + 1, currentLength - position);

        System.arraycopy(poly.ys, 0, newys, 0, position);
        System.arraycopy(poly.ys, position, newys, position + 1, currentLength - position);
      }

      int offsetX;
      int offsetY;

      if (gpo.getX() == -1 && gpo.getY() == -1) {
        offsetX = projection.getWidth() / 2;
        offsetY = projection.getHeight() / 2;
      } else {
        offsetX = gpo.getX();
        offsetY = gpo.getY();
      }

      if (poly.coordMode == OMPoly.COORDMODE_ORIGIN || position == 0) { // cover
        // the
        // first
        // point

        newxs[position] = x - offsetX;
        newys[position] = y - offsetY;
      } else { // CMode Previous offset deltas
        newxs[position] = x - offsetX - newxs[position - 1];
        newys[position] = y - offsetY - newys[position - 1];
      }

      if (position == 0) {
        // Could call projection.getCenter() but that might
        // break if/when we make other projection
        // libraries/paradigms active.
        LatLonPoint llpnt = projection.inverse(offsetX, offsetY, new LatLonPoint.Double());

        if (rads) {
          poly.lat = llpnt.getRadLat();
          poly.lon = llpnt.getRadLon();
        } else {
          poly.lat = llpnt.getY();
          poly.lon = llpnt.getX();
        }
      }

      poly.setLocation(poly.lat, poly.lon, poly.getUnits(), newxs, newys);
    }

    // Need to reset the arrowhead when an end point is added,
    // removing it from the shape when the point gets added.
    // Otherwise, you end up with a arrowhead at each junction of
    // the polygon.
    OMArrowHead omah = poly.getArrowHead();
    poly.setArrowHead(null);

    // Reset the arrowhead so it will get drawn on the new
    // segment.
    poly.setArrowHead(omah);
    polyGrabPoints.add(position, gp);

    if (gpo != null) {
      gpo.addGrabPoint(gp);
    }

    // This is the standard call that needs to be made here, the
    // arrowhead changes are around this.
    poly.regenerate(projection);
    gp.generate(projection);

    return position;
  }