Esempio n. 1
0
  @Override
  public void draw(final Canvas c, final MapView mapView, final boolean shadow) {

    if (shadow) {
      return;
    }

    // If map views is animating, don't update, scale will be wrong.
    if (mapView.isAnimating()) {
      return;
    }

    final int zoomLevel = mapView.getZoomLevel();

    if (zoomLevel >= minZoom) {
      final Projection projection = mapView.getProjection();

      if (projection == null) {
        return;
      }

      final IGeoPoint center = projection.fromPixels((screenWidth / 2), screenHeight / 2);
      if (zoomLevel != lastZoomLevel
          || (int) (center.getLatitudeE6() / 1E6) != (int) (lastLatitude / 1E6)) {
        lastZoomLevel = zoomLevel;
        lastLatitude = center.getLatitudeE6();
        createScaleBarPicture(mapView);
      }

      mBounds.set(projection.getScreenRect());
      mBounds.offset((int) xOffset, (int) yOffset);

      mBounds.set(
          mBounds.left,
          mBounds.top,
          mBounds.left + scaleBarPicture.getWidth(),
          mBounds.top + scaleBarPicture.getHeight());
      c.drawPicture(scaleBarPicture, mBounds);
    }
  }
Esempio n. 2
0
  @Override
  protected void draw(final Canvas pC, final MapView pOsmv, final boolean shadow) {

    if (shadow) {
      return;
    }

    // Don't draw if we are animating
    if (pOsmv.isAnimating()) {
      return;
    }

    // Calculate the half-world size
    final Projection projection = pOsmv.getProjection();
    final int zoomLevel = projection.getZoomLevel();
    mWorldSize_2 = TileSystem.MapSize(zoomLevel) / 2;

    // Save the Mercator coordinates of what is on the screen
    mViewportRect.set(projection.getScreenRect());
    mViewportRect.offset(mWorldSize_2, mWorldSize_2);

    // Start calculating the tile area with the current viewport
    mTileArea.set(mViewportRect);

    // Get the target zoom level difference.
    int miniMapZoomLevelDifference = getZoomDifference();

    // Make sure the zoom level difference isn't below the minimum zoom level
    if (zoomLevel - getZoomDifference() < mTileProvider.getMinimumZoomLevel()) {
      miniMapZoomLevelDifference +=
          zoomLevel - getZoomDifference() - mTileProvider.getMinimumZoomLevel();
    }

    // Shift the screen coordinates into the target zoom level
    mTileArea.set(
        mTileArea.left >> miniMapZoomLevelDifference,
        mTileArea.top >> miniMapZoomLevelDifference,
        mTileArea.right >> miniMapZoomLevelDifference,
        mTileArea.bottom >> miniMapZoomLevelDifference);

    // Limit the area we are interested in for tiles to be the MAP_WIDTH by MAP_HEIGHT and
    // centered on the center of the screen
    mTileArea.set(
        mTileArea.centerX() - (getWidth() / 2),
        mTileArea.centerY() - (getHeight() / 2),
        mTileArea.centerX() + (getWidth() / 2),
        mTileArea.centerY() + (getHeight() / 2));

    // Get the area where we will draw the minimap in screen coordinates
    mMiniMapCanvasRect.set(
        mViewportRect.right - getPadding() - getWidth(),
        mViewportRect.bottom - getPadding() - getHeight(),
        mViewportRect.right - getPadding(),
        mViewportRect.bottom - getPadding());
    mMiniMapCanvasRect.offset(-mWorldSize_2, -mWorldSize_2);

    // Draw a solid background where the minimap will be drawn with a 2 pixel inset
    pC.drawRect(
        mMiniMapCanvasRect.left - 2,
        mMiniMapCanvasRect.top - 2,
        mMiniMapCanvasRect.right + 2,
        mMiniMapCanvasRect.bottom + 2,
        mPaint);

    super.drawTiles(
        pC,
        projection.getZoomLevel() - miniMapZoomLevelDifference,
        TileSystem.getTileSize(),
        mTileArea);
  }
  /**
   * This method draws the line. Note - highly optimized to handle long paths, proceed with care.
   * Should be fine up to 10K points.
   */
  @Override
  protected void draw(final Canvas canvas, final MapView mapView, final boolean shadow) {

    if (shadow) {
      return;
    }

    if (this.mPoints.size() < 2) {
      // nothing to paint
      return;
    }

    final Projection pj = mapView.getProjection();

    // precompute new points to the intermediate projection.
    final int size = this.mPoints.size();

    while (this.mPointsPrecomputed < size) {
      final Point pt = this.mPoints.get(this.mPointsPrecomputed);
      pj.toMapPixelsProjected(pt.x, pt.y, pt);

      this.mPointsPrecomputed++;
    }

    Point screenPoint0 = null; // points on screen
    Point screenPoint1 = null;
    Point projectedPoint0; // points from the points list
    Point projectedPoint1;

    // clipping rectangle in the intermediate projection, to avoid performing projection.
    final Rect clipBounds = pj.fromPixelsToProjected(pj.getScreenRect());

    mPath.rewind();
    projectedPoint0 = this.mPoints.get(size - 1);
    mLineBounds.set(projectedPoint0.x, projectedPoint0.y, projectedPoint0.x, projectedPoint0.y);

    for (int i = size - 2; i >= 0; i--) {
      // compute next points
      projectedPoint1 = this.mPoints.get(i);
      mLineBounds.union(projectedPoint1.x, projectedPoint1.y);

      if (!Rect.intersects(clipBounds, mLineBounds)) {
        // skip this line, move to next point
        projectedPoint0 = projectedPoint1;
        screenPoint0 = null;
        continue;
      }

      // the starting point may be not calculated, because previous segment was out of clip
      // bounds
      if (screenPoint0 == null) {
        screenPoint0 = pj.toMapPixelsTranslated(projectedPoint0, this.mTempPoint1);
        mPath.moveTo(screenPoint0.x, screenPoint0.y);
      }

      screenPoint1 = pj.toMapPixelsTranslated(projectedPoint1, this.mTempPoint2);

      // skip this point, too close to previous point
      if (Math.abs(screenPoint1.x - screenPoint0.x) + Math.abs(screenPoint1.y - screenPoint0.y)
          <= 1) {
        continue;
      }

      mPath.lineTo(screenPoint1.x, screenPoint1.y);

      // update starting point to next position
      projectedPoint0 = projectedPoint1;
      screenPoint0.x = screenPoint1.x;
      screenPoint0.y = screenPoint1.y;
      mLineBounds.set(projectedPoint0.x, projectedPoint0.y, projectedPoint0.x, projectedPoint0.y);
    }

    canvas.drawPath(mPath, this.mPaint);
  }