/**
   * Compute weight and add edge to the graph
   *
   * @param way
   * @param from
   * @param to
   */
  private void addEdge(Way way, Node from, Node to) {
    LatLon fromLL = from.getCoor();
    LatLon toLL = from.getCoor();
    if (fromLL == null || toLL == null) {
      return;
    }
    double length = fromLL.greatCircleDistance(toLL);

    OsmEdge edge = new OsmEdge(way, from, to);
    edge.setSpeed(12.1);
    graph.addEdge(from, to, edge);
    // weight = getWeight(way);
    double weight = getWeight(way, length);
    setWeight(edge, length);
    logger.debug(
        "edge for way "
            + way.getId()
            + "(from node "
            + from.getId()
            + " to node "
            + to.getId()
            + ") has weight: "
            + weight);
    ((DirectedWeightedMultigraph<Node, OsmEdge>) graph).setEdgeWeight(edge, weight);
  }
 private boolean areCoordinatesValid(
     double minlat, double minlon, double maxlat, double maxlon) {
   return LatLon.isValidLat(minlat)
       && LatLon.isValidLat(maxlat)
       && LatLon.isValidLon(minlon)
       && LatLon.isValidLon(maxlon);
 }
Example #3
0
  private void testProj(Projection p) {
    double maxErrLat = 0, maxErrLon = 0;

    Bounds b = p.getWorldBoundsLatLon();

    text += String.format("*** %s %s\n", p.toString(), p.toCode());
    for (int num = 0; num < 1000; ++num) {

      double lat = rand.nextDouble() * (b.getMax().lat() - b.getMin().lat()) + b.getMin().lat();
      double lon = rand.nextDouble() * (b.getMax().lon() - b.getMin().lon()) + b.getMin().lon();

      LatLon ll = new LatLon(lat, lon);

      for (int i = 0; i < 10; ++i) {
        EastNorth en = p.latlon2eastNorth(ll);
        ll = p.eastNorth2latlon(en);
      }
      maxErrLat = Math.max(maxErrLat, Math.abs(lat - ll.lat()));
      maxErrLon = Math.max(maxErrLon, Math.abs(lon - ll.lon()));
    }

    String mark = "";
    if (maxErrLat + maxErrLon > 1e-5) {
      mark = "--FAILED-- ";
      error = true;
    }
    text += String.format("%s errorLat: %s errorLon: %s\n", mark, maxErrLat, maxErrLon);
  }
Example #4
0
 /**
  * Formats a name for a history node
  *
  * @param node the node
  * @return the name
  */
 @Override
 public String format(HistoryNode node) {
   StringBuilder sb = new StringBuilder();
   String name;
   if (Main.pref.getBoolean("osm-primitives.localize-name", true)) {
     name = node.getLocalName();
   } else {
     name = node.getName();
   }
   if (name == null) {
     sb.append(node.getId());
   } else {
     sb.append(name);
   }
   LatLon coord = node.getCoords();
   if (coord != null) {
     sb.append(" (")
         .append(coord.latToString(CoordinateFormat.getDefaultFormat()))
         .append(", ")
         .append(coord.lonToString(CoordinateFormat.getDefaultFormat()))
         .append(")");
   }
   decorateNameWithId(sb, node);
   return sb.toString();
 }
Example #5
0
 /** output a point */
 private void wayPoint(WayPoint pnt, int mode) {
   String type;
   switch (mode) {
     case WAY_POINT:
       type = "wpt";
       break;
     case ROUTE_POINT:
       type = "rtept";
       break;
     case TRACK_POINT:
       type = "trkpt";
       break;
     default:
       throw new RuntimeException(tr("Unknown mode {0}.", mode));
   }
   if (pnt != null) {
     LatLon c = pnt.getCoor();
     String coordAttr = "lat=\"" + c.lat() + "\" lon=\"" + c.lon() + '\"';
     if (pnt.attr.isEmpty()) {
       inline(type, coordAttr);
     } else {
       openAtt(type, coordAttr);
       writeAttr(pnt, WPT_KEYS);
       closeln(type);
     }
   }
 }
Example #6
0
 public static String getURL(LatLon pos, int zoom) {
   // Truncate lat and lon to something more sensible
   int decimals = (int) Math.pow(10, (zoom / 3));
   double lat = (Math.round(pos.lat() * decimals));
   lat /= decimals;
   double lon = (Math.round(pos.lon() * decimals));
   lon /= decimals;
   return "http://www.openstreetmap.org/?lat=" + lat + "&lon=" + lon + "&zoom=" + zoom;
 }
 @Override
 public void actionPerformed(GpsActionEvent event) {
   LatLon coordinates = event.getCoordinates();
   System.out.println(
       getClass().getSimpleName()
           + " KOORD: "
           + coordinates.lat()
           + ", "
           + coordinates.lon()
           + " params: "
           + getParameters());
 }
Example #8
0
 /**
  * Replies the download area.
  *
  * @return The download area
  */
 public Bounds getDownloadArea() {
   double[] values = new double[4];
   for (int i = 0; i < 4; i++) {
     try {
       values[i] = Double.parseDouble(latlon[i].getText());
     } catch (NumberFormatException x) {
       return null;
     }
   }
   if (!LatLon.isValidLat(values[0]) || !LatLon.isValidLon(values[1])) return null;
   if (!LatLon.isValidLat(values[2]) || !LatLon.isValidLon(values[3])) return null;
   return new Bounds(values);
 }
Example #9
0
 /**
  * Single point Bounds defined by point [lat,lon]. Coordinates will be rounded to osm precision if
  * {@code roundToOsmPrecision} is true.
  *
  * @param lat latitude of given point.
  * @param lon longitude of given point.
  * @param roundToOsmPrecision defines if lat/lon will be rounded.
  * @since 6203
  */
 public Bounds(double lat, double lon, boolean roundToOsmPrecision) {
   // Do not call this(b, b) to avoid GPX performance issue (see #7028) until roundToOsmPrecision()
   // is improved
   if (roundToOsmPrecision) {
     this.minLat = LatLon.roundToOsmPrecision(lat);
     this.minLon = LatLon.roundToOsmPrecision(lon);
   } else {
     this.minLat = lat;
     this.minLon = lon;
   }
   this.maxLat = this.minLat;
   this.maxLon = this.minLon;
 }
Example #10
0
  /**
   * @param zoom level of the tile
   * @return how many pixels of the screen occupies one pixel of the tile
   */
  private double getTileToScreenRatio(int zoom) {
    MapView mv = Main.map.mapView;
    LatLon topLeft = mv.getLatLon(0, 0);
    LatLon botLeft = mv.getLatLon(0, tileSource.getTileSize());

    TileXY topLeftTile = tileSource.latLonToTileXY(topLeft.toCoordinate(), zoom);

    ICoordinate north =
        tileSource.tileXYToLatLon(topLeftTile.getXIndex(), topLeftTile.getYIndex(), zoom);
    ICoordinate south =
        tileSource.tileXYToLatLon(topLeftTile.getXIndex(), topLeftTile.getYIndex() + 1, zoom);

    return Math.abs((north.getLat() - south.getLat()) / (topLeft.lat() - botLeft.lat()));
  }
Example #11
0
 public Bounds(
     double minlat, double minlon, double maxlat, double maxlon, boolean roundToOsmPrecision) {
   if (roundToOsmPrecision) {
     this.minLat = LatLon.roundToOsmPrecision(minlat);
     this.minLon = LatLon.roundToOsmPrecision(minlon);
     this.maxLat = LatLon.roundToOsmPrecision(maxlat);
     this.maxLon = LatLon.roundToOsmPrecision(maxlon);
   } else {
     this.minLat = minlat;
     this.minLon = minlon;
     this.maxLat = maxlat;
     this.maxLon = maxlon;
   }
 }
Example #12
0
 /**
  * Returns the heading, in radians, that you have to use to get from this lat/lon to another.
  *
  * @param other the "destination" position
  * @return heading
  */
 public double heading(LatLon other) {
   double rv;
   if (other.lat() == lat()) {
     rv = (other.lon() > lon() ? Math.PI / 2 : Math.PI * 3 / 2);
   } else {
     rv = Math.atan((other.lon() - lon()) / (other.lat() - lat()));
     if (rv < 0) {
       rv += Math.PI;
     }
     if (other.lon() < lon()) {
       rv += Math.PI;
     }
   }
   return rv;
 }
Example #13
0
 /**
  * Replies the length of the way, in metres, as computed by {@link LatLon#greatCircleDistance}.
  *
  * @return The length of the way, in metres
  * @since 4138
  */
 public double getLength() {
   double length = 0;
   Node lastN = null;
   for (Node n : nodes) {
     if (lastN != null) {
       LatLon lastNcoor = lastN.getCoor();
       LatLon coor = n.getCoor();
       if (lastNcoor != null && coor != null) {
         length += coor.greatCircleDistance(lastNcoor);
       }
     }
     lastN = n;
   }
   return length;
 }
 /**
  * Angle between line AB and CD
  *
  * @param a Point A.
  * @param b Point B.
  * @param c Point C.
  * @param d Point D.
  * @return Angle in degrees.
  */
 public static double angleOfLines(LatLon a, LatLon b, LatLon c, LatLon d) {
   return (Math.abs(
               Math.atan2(a.lat() - b.lat(), a.lon() - b.lon())
                   - Math.atan2(c.lat() - d.lat(), c.lon() - d.lon()))
           / Math.PI
           * 180)
       % 360;
 }
Example #15
0
 double getLength() {
   List<LatLon> pts = getPoints();
   Iterator<LatLon> it1, it2;
   LatLon pp1, pp2;
   if (pts.size() < 2) return 0;
   it1 = pts.listIterator(0);
   it2 = pts.listIterator(1);
   double len = 0;
   for (int i = 0; i < pts.size() - 1; i++) {
     pp1 = it1.next();
     pp2 = it2.next();
     len += pp1.greatCircleDistance(pp2);
   }
   return len;
 }
Example #16
0
 public Bounds(double[] coords, boolean roundToOsmPrecision) {
   CheckParameterUtil.ensureParameterNotNull(coords, "coords");
   if (coords.length != 4)
     throw new IllegalArgumentException(
         MessageFormat.format("Expected array of length 4, got {0}", coords.length));
   if (roundToOsmPrecision) {
     this.minLat = LatLon.roundToOsmPrecision(coords[0]);
     this.minLon = LatLon.roundToOsmPrecision(coords[1]);
     this.maxLat = LatLon.roundToOsmPrecision(coords[2]);
     this.maxLon = LatLon.roundToOsmPrecision(coords[3]);
   } else {
     this.minLat = coords[0];
     this.minLon = coords[1];
     this.maxLat = coords[2];
     this.maxLon = coords[3];
   }
 }
Example #17
0
 @Override
 public int hashCode() {
   final int prime = 31;
   int result = 1;
   result = prime * result + ((eastNorth == null) ? 0 : eastNorth.hashCode());
   result = prime * result + ((latlon == null) ? 0 : latlon.hashCode());
   result = prime * result + (modified ? 1231 : 1237);
   return result;
 }
Example #18
0
 protected Bounds build() {
   double minlon, minlat, maxlon, maxlat;
   try {
     minlat = Double.parseDouble(latlon[0].getText().trim());
     minlon = Double.parseDouble(latlon[1].getText().trim());
     maxlat = Double.parseDouble(latlon[2].getText().trim());
     maxlon = Double.parseDouble(latlon[3].getText().trim());
   } catch (NumberFormatException e) {
     return null;
   }
   if (!LatLon.isValidLon(minlon)
       || !LatLon.isValidLon(maxlon)
       || !LatLon.isValidLat(minlat)
       || !LatLon.isValidLat(maxlat)) return null;
   if (minlon > maxlon) return null;
   if (minlat > maxlat) return null;
   return new Bounds(minlat, minlon, maxlat, maxlon);
 }
    @Override
    public void run() {
      if (!active) return;

      LatLon min = bbox.getMin();
      LatLon max = bbox.getMax();

      // Extend the area to download beond the view
      double t = Main.pref.getDouble("plugin.continuos_download.extra_download", 0.1);
      double dLat = Math.abs(max.lat() - min.lat()) * t;
      double dLon = Math.abs(max.lon() - min.lon()) * t;

      Bounds newBbox =
          new Bounds(min.lat() - dLat, min.lon() - dLon, max.lat() + dLat, max.lon() + dLon);

      // Do not try to download an area if the user have zoomed far out
      if (newBbox.getArea() < Main.pref.getDouble("plugin.continuos_download.max_area", 0.25))
        getStrat().fetch(newBbox);
    }
  private void infoSync(LatLon pos, ProgressMonitor progressMonitor) {

    progressMonitor.beginTask(null, 3);
    try {
      mRuian.prepareData(pos);
      htmlText = mRuian.getHtml();
      coordinatesText = PointInfoUtils.formatCoordinates(pos.lat(), pos.lon());

    } finally {
      progressMonitor.finishTask();
    }
    progressMonitor.invalidate();
    if (htmlText.length() == 0) {
      GuiHelper.runInEDTAndWait(
          () ->
              PointInfoUtils.showNotification(
                  tr("Data not available.") + "\n(" + pos.toDisplayString() + ")", "warning"));
      return;
    }
  }
Example #21
0
  public void update(Camera camera, Perspective3D perspective3d) {

    Point3d cameraPoint = camera.getPoint();
    Vector3d cameraRotation = camera.getAngle();

    Perspective3D perspective = perspective3d;

    EastNorth eastNorth = perspective.toEastNorth(cameraPoint.x, -cameraPoint.z);

    Projection proj = Main.getProjection();

    LatLon latLon = proj.eastNorth2latlon(eastNorth);

    // XXX update cache
    this.photo.setLat(latLon.lat());
    this.photo.setLon(latLon.lon());
    this.photo.setHeight(cameraPoint.y);

    this.photo.setRotate(cameraRotation.x, cameraRotation.y, cameraRotation.z);
  }
 @Override
 protected void realRun() throws IOException, OsmTransferException {
   LatLon center = Main.getProjection().eastNorth2latlon(Main.map.mapView.getCenter());
   scale =
       Settings.getScaleNumerator()
           / Settings.getScaleDivisor()
           / Math.cos(Math.toRadians(center.lat()));
   this.center = projection.latlon2eastNorth(center);
   try {
     SVGUniverse universe = new SVGUniverse();
     universe.setVerbose(Main.pref.getBoolean("importvec.verbose", false));
     for (File f : files) {
       if (f.isDirectory()) continue;
       if (canceled) {
         return;
       }
       SVGDiagram diagram = universe.getDiagram(f.toURI());
       ShapeElement root = diagram.getRoot();
       if (root == null) {
         throw new IOException("Can't find root SVG element");
       }
       Rectangle2D bbox = root.getBoundingBox();
       this.center = this.center.add(-bbox.getCenterX() * scale, bbox.getCenterY() * scale);
       processElement(root, null);
     }
   } catch (IOException e) {
     throw e;
   } catch (Exception e) {
     throw new IOException(e);
   }
   LinkedList<Command> cmds = new LinkedList<>();
   for (Node n : nodes) {
     cmds.add(new AddCommand(n));
   }
   for (Way w : ways) {
     cmds.add(new AddCommand(w));
   }
   Main.main.undoRedo.add(new SequenceCommand("Import primitives", cmds));
 }
Example #23
0
  /**
   * Returns maximum number of simplified line points divided by line segment length max((k-1) /
   * (L(i,i+1)+L(i+1,i+2)+...+L(i+k-1,i+k))) [ i=1..n-k ]
   *
   * @param k - window size (number of points to average points per km
   */
  public double getNodesPerKm(int k) {
    List<LatLon> pts = simplePoints;
    if (!wasSimplified()) pts = points;
    int n = pts.size();
    if (n < 2) return 0;
    if (k < 2) k = 2;
    if (k > n) k = n;

    LatLon pp1, pp2 = null;
    Iterator<LatLon> it1, it2;
    it1 = pts.listIterator(0);
    it2 = pts.listIterator(1);
    double lens[] = new double[n];
    for (int i = 0; i < n - 1; i++) {
      pp1 = it1.next();
      // p1 = getPoint(pp1);
      pp2 = it2.next();
      // p2 =sa getPoint(pp2);
      lens[i] = pp1.greatCircleDistance(pp2);
    }
    double pkm = 0, maxpkm = 0;
    double len = 0;
    int seg = 0; // averaged segments counts
    for (int i = 1; i < n; i++) {
      len += lens[i - 1]; // add next next point
      // remove old segment
      if (i > k) {
        seg = k;
        len -= lens[i - k - 1];
      } else seg = i;
      if (i >= k || i == n - 1) {
        // len is length of points[i-windowSize] .. points[i]
        if (len > 0) pkm = seg / len * 1000;
        // System.out.println("i="+i+" pkm="+len+" pkm="+pkm);
        if (pkm > maxpkm) maxpkm = pkm;
      }
    }
    return Math.round(maxpkm);
  }
Example #24
0
 /**
  * Computes the distance between this lat/lon and another point on the earth. Uses Haversine
  * formular.
  *
  * @param other the other point.
  * @return distance in metres.
  */
 public double greatCircleDistance(LatLon other) {
   double R = 6378135;
   double sinHalfLat = sin(toRadians(other.lat() - this.lat()) / 2);
   double sinHalfLon = sin(toRadians(other.lon() - this.lon()) / 2);
   double d =
       2
           * R
           * asin(
               sqrt(
                   sinHalfLat * sinHalfLat
                       + cos(toRadians(this.lat()))
                           * cos(toRadians(other.lat()))
                           * sinHalfLon
                           * sinHalfLon));
   // For points opposite to each other on the sphere,
   // rounding errors could make the argument of asin greater than 1
   // (This should almost never happen.)
   if (java.lang.Double.isNaN(d)) {
     System.err.println("Error: NaN in greatCircleDistance");
     d = PI * R;
   }
   return d;
 }
Example #25
0
 /**
  * Determines if the given point {@code ll} is within these bounds.
  *
  * @param ll The lat/lon to check
  * @return {@code true} if {@code ll} is within these bounds, {@code false} otherwise
  */
 public boolean contains(LatLon ll) {
   if (ll.lat() < minLat || ll.lat() > maxLat) return false;
   if (crosses180thMeridian()) {
     if (ll.lon() > maxLon && ll.lon() < minLon) return false;
   } else {
     if (ll.lon() < minLon || ll.lon() > maxLon) return false;
   }
   return true;
 }
Example #26
0
 @Override
 public boolean equals(Object obj) {
   if (this == obj) return true;
   if (obj == null) return false;
   if (getClass() != obj.getClass()) return false;
   OldNodeState other = (OldNodeState) obj;
   if (eastNorth == null) {
     if (other.eastNorth != null) return false;
   } else if (!eastNorth.equals(other.eastNorth)) return false;
   if (latlon == null) {
     if (other.latlon != null) return false;
   } else if (!latlon.equals(other.latlon)) return false;
   if (modified != other.modified) return false;
   return true;
 }
Example #27
0
 protected void check() {
   double value = 0;
   try {
     value = Double.parseDouble(tfLatValue.getText());
   } catch (NumberFormatException ex) {
     setErrorMessage(
         tfLatValue,
         tr("The string ''{0}'' is not a valid double value.", tfLatValue.getText()));
     return;
   }
   if (!LatLon.isValidLat(value)) {
     setErrorMessage(
         tfLatValue, tr("Value for latitude in range [-90,90] required.", tfLatValue.getText()));
     return;
   }
   resetErrorMessage(tfLatValue);
 }
  public void selectFeatures(int x, int y) {
    int pixelDelta = 2;
    LatLon clickUL = Main.map.mapView.getLatLon(x - pixelDelta, y - pixelDelta);
    LatLon clickLR = Main.map.mapView.getLatLon(x + pixelDelta, y + pixelDelta);

    Envelope envelope =
        new Envelope(
            Math.min(clickUL.lon(), clickLR.lon()),
            Math.max(clickUL.lon(), clickLR.lon()),
            Math.min(clickUL.lat(), clickLR.lat()),
            Math.max(clickUL.lat(), clickLR.lat()));

    ReferencedEnvelope mapArea = new ReferencedEnvelope(envelope, crsOSMI);

    Intersects filter = ff.intersects(ff.property("msGeometry"), ff.literal(mapArea));
    //
    // Select features in all layers
    //
    content.layers().clear();

    // Iterate through features and build a list that intersects the above
    // envelope
    for (int idx = 0; idx < arrFeatures.size(); ++idx) {
      OSMIFeatureTracker tracker = arrFeatures.get(idx);
      FeatureCollection<SimpleFeatureType, SimpleFeature> features = tracker.getFeatures();

      SimpleFeatureSource tempfs = DataUtilities.source(features);
      FeatureCollection<SimpleFeatureType, SimpleFeature> selectedFeatures;

      try {
        selectedFeatures = tempfs.getFeatures(filter);
        Set<FeatureId> IDs = new HashSet<>();

        try (FeatureIterator<SimpleFeature> iter = selectedFeatures.features()) {

          Main.info("Selected features " + selectedFeatures.size());

          while (iter.hasNext()) {
            SimpleFeature feature = iter.next();
            IDs.add(feature.getIdentifier());
          }
        }

        geometryType = selectGeomType.get(idx + layerOffset);
        Style style = createDefaultStyle(idx + layerOffset, IDs);
        content.addLayer(new FeatureLayer(features, style));
      } catch (IOException e) {
        Main.error(e);
      }
    }

    bIsChanged = true;
  }
Example #29
0
  /**
   * Determines whether a way is oriented clockwise.
   *
   * <p>Internals: Assuming a closed non-looping way, compute twice the area of the polygon using
   * the formula {@code 2 * area = sum (X[n] * Y[n+1] - X[n+1] * Y[n])}. If the area is negative the
   * way is ordered in a clockwise direction.
   *
   * <p>See http://paulbourke.net/geometry/polyarea/
   *
   * @param w the way to be checked.
   * @return true if and only if way is oriented clockwise.
   * @throws IllegalArgumentException if way is not closed (see {@link Way#isClosed}).
   */
  public static boolean isClockwise(Way w) {
    if (!w.isClosed()) {
      throw new IllegalArgumentException("Way must be closed to check orientation.");
    }

    double area2 = 0.;
    int nodesCount = w.getNodesCount();

    for (int node = 1; node <= /*sic! consider last-first as well*/ nodesCount; node++) {
      LatLon coorPrev = w.getNode(node - 1).getCoor();
      LatLon coorCurr = w.getNode(node % nodesCount).getCoor();
      area2 += coorPrev.lon() * coorCurr.lat();
      area2 -= coorCurr.lon() * coorPrev.lat();
    }
    return area2 < 0;
  }
  @Override
  public void paint(Graphics2D g, MapView mv, Bounds box) {
    LatLon min = box.getMin();
    LatLon max = box.getMax();

    Envelope envelope2 =
        new Envelope(
            Math.min(min.lat(), max.lat()),
            Math.max(min.lat(), max.lat()),
            Math.min(min.lon(), max.lon()),
            Math.max(min.lon(), max.lon()));

    ReferencedEnvelope mapArea = new ReferencedEnvelope(envelope2, crsOSMI);

    renderer.setInteractive(false);
    renderer.paint(g, mv.getBounds(), mapArea);
    bIsChanged = false;
  }