Beispiel #1
0
  @Override
  public void draw(Canvas canvas, MapView mapView, boolean shadow) {

    super.draw(canvas, mapView, shadow);

    if (shadow) {
      return;
    }

    Projection projection = mapView.getProjection();
    Path path = new Path();
    boolean isFirst = true;

    for (int i = 0; i < pointsSize; i++) {
      GeoPoint gPoint = points.get(i);
      Point pixelPoint = pixelPoints[i];

      projection.toPixels(gPoint, pixelPoint);

      if (isFirst) {
        path.moveTo(pixelPoint.x, pixelPoint.y);
        isFirst = false;
      } else {
        path.lineTo(pixelPoint.x, pixelPoint.y);
      }
    }

    canvas.drawPath(path, mPaint);
  }
  @Override
  protected void drawMyLocation(
      Canvas canvas, MapView mapView, Location lastFix, GeoPoint myLocation, long when) {
    if (!bugged) {
      try {
        super.drawMyLocation(canvas, mapView, lastFix, myLocation, when);
      } catch (Exception e) {
        // we found a buggy phone, draw the location icons ourselves
        bugged = true;
      }
    }

    if (bugged) {
      if (drawable == null) {

        accuracyPaint = new Paint();
        accuracyPaint.setAntiAlias(true);
        accuracyPaint.setStrokeWidth(2.0f);

        drawable =
            mapView
                .getContext()
                .getResources()
                .getDrawable(R.drawable.ic_maps_indicator_current_position);
        width = drawable.getIntrinsicWidth();
        height = drawable.getIntrinsicHeight();
        center = new Point();
        left = new Point();
      }

      Projection projection = mapView.getProjection();
      double latitude = lastFix.getLatitude();
      double longitude = lastFix.getLongitude();
      float accuracy = lastFix.getAccuracy();

      float[] result = new float[1];

      Location.distanceBetween(latitude, longitude, latitude, longitude + 1, result);
      float longitudeLineDistance = result[0];

      GeoPoint leftGeo =
          new GeoPoint(
              (int) (latitude * 1e6), (int) ((longitude - accuracy / longitudeLineDistance) * 1e6));
      projection.toPixels(leftGeo, left);
      projection.toPixels(myLocation, center);
      int radius = center.x - left.x;

      accuracyPaint.setColor(0xff6666ff);
      accuracyPaint.setStyle(Style.STROKE);
      canvas.drawCircle(center.x, center.y, radius, accuracyPaint);

      accuracyPaint.setColor(0x186666ff);
      accuracyPaint.setStyle(Style.FILL);
      canvas.drawCircle(center.x, center.y, radius, accuracyPaint);

      drawable.setBounds(
          center.x - width / 2, center.y - height / 2, center.x + width / 2, center.y + height / 2);
      drawable.draw(canvas);
    }
  }
  @Override
  public void draw(Canvas canvas, MapView mapView, boolean shadow) {
    Projection projection = mapView.getProjection();

    if (shadow == false) {
      // Get the current location
      Double latitude = 0.0, longitude = 0.0;
      if (location != null) {
        latitude = location.getLatitude() * 1E6;
        longitude = location.getLongitude() * 1E6;
      }
      GeoPoint geoPoint = new GeoPoint(latitude.intValue(), longitude.intValue());
      // Convert the location to screen pixles
      Point point = new Point();
      projection.toPixels(geoPoint, point);
      // Start Drawing
      Paint paint = new Paint();
      paint.setAntiAlias(true);
      paint.setARGB(150, 238, 17, 100);
      canvas.drawCircle(point.x, point.y, mRadius + 4, paint);
      paint.setARGB(255, 255, 255, 0);
      canvas.drawCircle(point.x, point.y, mRadius + 2, paint);
      paint.setARGB(250, 255, 0, 0);
      canvas.drawCircle(point.x, point.y, mRadius, paint);
    }
    super.draw(canvas, mapView, shadow);
  }
  @Override
  public void draw(Canvas canvas, MapView mapView, boolean shadow) {

    super.draw(canvas, mapView, shadow);

    Projection projection = mapView.getProjection();

    int latSpan = mapView.getLatitudeSpan();
    int lngSpan = mapView.getLongitudeSpan();
    GeoPoint mapCenter = mapView.getMapCenter();
    int mapLeftGeo = mapCenter.getLongitudeE6() - (lngSpan / 2);
    int mapRightGeo = mapCenter.getLongitudeE6() + (lngSpan / 2);

    int mapTopGeo = mapCenter.getLatitudeE6() - (latSpan / 2);
    int mapBottomGeo = mapCenter.getLatitudeE6() + (latSpan / 2);

    GeoPoint geoPoint = this.getSampleLocation();

    if ((geoPoint.getLatitudeE6() > mapTopGeo && geoPoint.getLatitudeE6() < mapBottomGeo)
        && (geoPoint.getLongitudeE6() > mapLeftGeo && geoPoint.getLongitudeE6() < mapRightGeo)) {
      Point myPoint = new Point();
      projection.toPixels(geoPoint, myPoint);
      Bitmap marker =
          BitmapFactory.decodeResource(mapView.getContext().getResources(), R.drawable.markerblue);
      canvas.drawBitmap(marker, myPoint.x - 15, myPoint.y - 30, null);
    }
  }
    @Override
    protected HttpResult<Iterable<Region>> doInBackground(Void... voids) {
      Projection projection = mapView.getProjection();

      // We want to download data that's off screen so the user can see something while panning
      GeoPoint northWest = projection.fromPixels(-mapView.getWidth(), -mapView.getHeight());
      GeoPoint southEast = projection.fromPixels(2 * mapView.getWidth(), 2 * mapView.getHeight());

      Location northWestLoc = LocationConversionHelper.location(northWest);
      Location southEastLoc = LocationConversionHelper.location(southEast);

      int size = min(mapView.getWidth(), mapView.getHeight()) / settingsHelper.getHeatMapDensity();
      if (size < 1) size = 1;

      int gridSizeX = MAP_BUFFER_SIZE * mapView.getWidth() / size;
      int gridSizeY = MAP_BUFFER_SIZE * mapView.getHeight() / size;

      return averagesDriver.index(
          sensorManager.getVisibleSensor(),
          northWestLoc.getLongitude(),
          northWestLoc.getLatitude(),
          southEastLoc.getLongitude(),
          southEastLoc.getLatitude(),
          gridSizeX,
          gridSizeY);
    }
  @Override
  public void draw(Canvas canvas, MapView mapView, boolean shadow) {
    if (!this.visible) return;

    // long start = System.currentTimeMillis();

    Projection projection = mapView.getProjection();
    Path p = new Path();
    Paint polygonPaint = new Paint();
    polygonPaint.setStrokeWidth(this.style.width);
    polygonPaint.setColor(this.style.color);
    polygonPaint.setStyle(Paint.Style.STROKE);
    polygonPaint.setAntiAlias(true);

    for (int i = 0; i < path.size(); i++) {
      if (i == path.size() - 1) {
        break;
      }
      Point from = new Point();
      Point to = new Point();
      projection.toPixels(path.get(i), from);
      projection.toPixels(path.get(i + 1), to);
      if (i == 0) {
        p.moveTo(from.x, from.y);
      }
      p.lineTo(to.x, to.y);
    }

    canvas.drawPath(p, polygonPaint);

    // Log.d("Tracker", "Path drawing complete in " + String.valueOf(System.currentTimeMillis() -
    // start) + "ms");
  }
  @Override
  public void draw(Canvas canvas, MapView mapView, boolean shadow) {
    // Get the map projection to convert lat/long to screen coordinates
    Projection projection = mapView.getProjection();

    Point lPoint = new Point();
    projection.toPixels(locationPoint, lPoint);

    // Draw the overlay
    if (shadow == false) {
      if (friendLocations.size() > 0) {
        Iterator<String> e = friendLocations.keySet().iterator();
        do {
          // Get the name and location of each contact
          String name = e.next();
          Location location = friendLocations.get(name);

          // Convert the lat / long to a Geopoint
          Double latitude = location.getLatitude() * 1E6;
          Double longitude = location.getLongitude() * 1E6;
          GeoPoint geopoint = new GeoPoint(latitude.intValue(), longitude.intValue());

          // Ensure each contact is within 10km
          float dist = location.distanceTo(getLocation());
          if (dist < 10000) {
            Point point = new Point();
            projection.toPixels(geopoint, point);

            // Draw a line connecting the contact to your current location.
            canvas.drawLine(lPoint.x, lPoint.y, point.x, point.y, paint);

            // Draw a marker at the contact's location.
            RectF oval =
                new RectF(
                    point.x - markerRadius,
                    point.y - markerRadius,
                    point.x + markerRadius,
                    point.y + markerRadius);

            canvas.drawOval(oval, backPaint);
            oval.inset(2, 2);
            canvas.drawOval(oval, paint);

            // Draw the contact's name next to their position.
            float textWidth = paint.measureText(name);
            float textHeight = paint.getTextSize();
            RectF textRect =
                new RectF(
                    point.x + markerRadius,
                    point.y - textHeight,
                    point.x + markerRadius + 8 + textWidth,
                    point.y + 4);
            canvas.drawRoundRect(textRect, 3, 3, backPaint);
            canvas.drawText(name, point.x + markerRadius + 4, point.y, paint);
          }
        } while (e.hasNext());
      }
    }
    super.draw(canvas, mapView, shadow);
  }
  @Override
  public void draw(Canvas canvas, MapView mapView, boolean shadow) {
    Point current = new Point();
    Path path = new Path();
    Projection projection = mapView.getProjection();
    Iterator<GeoPoint> iterator = pointList.iterator();

    if (iterator.hasNext()) {
      projection.toPixels(iterator.next(), current);
      path.moveTo((float) current.x, (float) current.y);
    } else return;

    while (iterator.hasNext()) {
      projection.toPixels(iterator.next(), current);
      path.lineTo((float) current.x, (float) current.y);
    }

    Paint pathPaint = new Paint();
    pathPaint.setAntiAlias(true);
    pathPaint.setDither(true);
    pathPaint.setStrokeWidth(3.5f);
    pathPaint.setColor(Color.rgb(15, 200, 2));
    pathPaint.setStyle(Style.STROKE);
    canvas.drawPath(path, pathPaint);
  }
  @Override
  public void draw(Canvas canvas, MapView mapView, boolean shadow) {
    if (!shadow) {

      // Make sure to give mMarker bounds so it will draw in the overlay
      final int intrinsicWidth = mMarker.getIntrinsicWidth();
      final int intrinsicHeight = mMarker.getIntrinsicHeight();
      mMarker.setBounds(0, 0, intrinsicWidth, intrinsicHeight);

      mMarkerXOffset = -(intrinsicWidth / 2);
      mMarkerYOffset = -(intrinsicHeight / 2);

      Paint paint = new Paint();
      paint.setARGB(250, 0, 0, 0);
      paint.setAntiAlias(true);
      paint.setFakeBoldText(true);

      Point point2 = new Point();
      Projection p = mapView.getProjection();
      p.toPixels(mGeoPoint, point2);

      canvas.drawText(text, point2.x - intrinsicWidth, point2.y + intrinsicHeight, paint);
      super.draw(canvas, mapView, shadow);
      drawAt(canvas, mMarker, point2.x + mMarkerXOffset, point2.y + mMarkerYOffset, shadow);
    }
  }
  public boolean draw(Canvas canvas, MapView mapView, boolean shadow, long when) {
    Projection projection = mapView.getProjection();
    // if (shadow == false && _points != null) {
    for (ArrayList<GeoPoint> pair : pathCoords) {
      Path path = new Path();
      // We are creating the path
      GeoPoint gPointA = null;
      GeoPoint gPointB = null;
      for (int i = 0; i < 2; i++) {
        gPointA = pair.get(i);
        Point pointA = new Point();
        pointA = projection.toPixels(gPointA, pointA);
        if (i == 0) { // This is the start point
          gPointB = pair.get(i);
          path.moveTo(pointA.x, pointA.y);
        } else {
          path.lineTo(pointA.x, pointA.y);
        }
      }

      Paint paint = new Paint();
      paint.setAntiAlias(true);
      paint.setColor(_pathColor);
      paint.setStyle(Paint.Style.STROKE);
      paint.setStrokeWidth(5);
      paint.setAlpha(90);
      if ((!path.isEmpty()) && (isCurrentLocationVisible(gPointB, gPointA, mapView)))
        canvas.drawPath(path, paint);
    }
    // }
    return super.draw(canvas, mapView, shadow, when);
  }
  @Override
  public void draw(Canvas canvas, MapView mapView, boolean shadow) {
    // TODO Auto-generated method stub
    super.draw(canvas, mapView, shadow);

    GeoPoint centerGp = mapView.getMapCenter();
    Projection projection = mapView.getProjection();
    Point centerPoint = projection.toPixels(centerGp, null);

    drawCircle(canvas, centerPoint, mapView);
  }
 public void draw(Canvas canvas, MapView mapview, boolean flag) {
   Projection projection = mapview.getProjection();
   Paint paint = new Paint();
   Point point = new Point();
   projection.toPixels(gp1, point);
   paint.setColor(color);
   Point point1 = new Point();
   projection.toPixels(gp2, point1);
   paint.setStrokeWidth(5F);
   paint.setAlpha(120);
   canvas.drawLine(point.x, point.y, point1.x, point1.y, paint);
   super.draw(canvas, mapview, flag);
 }
  private void transformSegmentToCanvasDots() {
    Cursor trackCursor = null;
    GeoPoint geoPoint;
    mCalculatedPoints = 0;
    setStepSize();
    step = 0;

    try {
      trackCursor =
          this.mResolver.query(
              this.mSegmentUri,
              new String[] {Waypoints.LATITUDE, Waypoints.LONGITUDE, Waypoints.ACCURACY},
              null,
              null,
              null);
      if (trackCursor.moveToFirst()) {
        // Start point of the segments, possible a dot
        this.mStartPoint = extractGeoPoint(trackCursor);
        moveToGeoPoint(this.mStartPoint);

        Paint radiusPaint = new Paint();
        radiusPaint.setColor(Color.YELLOW);
        radiusPaint.setAlpha(100);

        do {
          geoPoint = extractGeoPoint(trackCursor);
          Point out = new Point();
          mProjection.toPixels(geoPoint, out);
          mCalculatedPoints++;
          Bitmap bitmap =
              BitmapFactory.decodeResource(this.mContext.getResources(), R.drawable.stip2);
          this.mCanvas.drawBitmap(bitmap, out.x - 8, out.y - 8, new Paint());
          float radius = mProjection.metersToEquatorPixels(trackCursor.getFloat(2));
          if (radius > 8f) {
            this.mCanvas.drawCircle(out.x, out.y, radius, radiusPaint);
          }
          this.mPrevScreenPoint.x = this.mScreenPoint.x;
          this.mPrevScreenPoint.y = this.mScreenPoint.y;
        } while (moveToNextWayPoint(trackCursor));

        // End point of the segments, possible a dot
        this.mEndPoint = extractGeoPoint(trackCursor);
      }
    } finally {
      if (trackCursor != null) {
        trackCursor.close();
      }
    }

    //      Log.d( TAG, "transformSegmentToPath stop: points "+mCalculatedPoints );
  }
  @Override
  public void draw(Canvas canvas, MapView mapView, boolean shadow) {

    Projection projection = mapView.getProjection();
    projection.toPixels(geopoint, point);

    circle.setColor(Color.parseColor("#EB5475"));
    circle.setAlpha(100);

    myCircleRadius =
        metersToRadius(CIRCLERADIUS, mapView, (double) geopoint.getLatitudeE6() / 1000000);

    canvas.drawCircle(point.x, point.y, myCircleRadius, circle);
  }
  /**
   * @param canvas
   * @param mapView
   * @param shadow
   * @see TrackingOverlay#draw(Canvas, MapView, boolean)
   */
  private void drawDots(Canvas canvas, MapView mapView, boolean shadow) {
    this.mCanvas = canvas;
    this.mScreenPoint = new Point();
    this.mPrevScreenPoint = new Point();
    mProjection = mapView.getProjection();
    mTopLeft = mProjection.fromPixels(0, 0);
    mBottumRight = mProjection.fromPixels(this.mCanvas.getWidth(), this.mCanvas.getHeight());

    transformSegmentToCanvasDots();

    drawStartStopCircles();

    super.draw(this.mCanvas, mapView, shadow);
    this.mCanvas = null;
  }
  @Override
  public boolean draw(Canvas canvas, MapView mapView, boolean shadow, long when) {
    Projection projection = mapView.getProjection();
    if (shadow == false) {

      Paint paint = new Paint();
      paint.setAntiAlias(true);
      Point point = new Point();
      projection.toPixels(gp1, point);
      paint.setColor(Color.BLUE);
      Point point2 = new Point();
      projection.toPixels(gp2, point2);
      paint.setStrokeWidth(2);
      canvas.drawLine((float) point.x, (float) point.y, (float) point2.x, (float) point2.y, paint);
    }
    return super.draw(canvas, mapView, shadow, when);
  }
  /** Either the Path or the Dots are calculated based on he current track coloring method */
  private synchronized void calculateTrackAsync() {
    GeoPoint oldTopLeft = mGeoTopLeft;
    GeoPoint oldBottumRight = mGeoBottumRight;
    mGeoTopLeft = mProjection.fromPixels(0, 0);
    mGeoBottumRight = mProjection.fromPixels(mWidth, mHeight);

    if (mRequeryFlag
        || oldTopLeft == null
        || oldBottumRight == null
        || mGeoTopLeft.getLatitudeE6() / 100 != oldTopLeft.getLatitudeE6() / 100
        || mGeoTopLeft.getLongitudeE6() / 100 != oldTopLeft.getLongitudeE6() / 100
        || mGeoBottumRight.getLatitudeE6() / 100 != oldBottumRight.getLatitudeE6() / 100
        || mGeoBottumRight.getLongitudeE6() / 100 != oldBottumRight.getLongitudeE6() / 100) {
      calculateStepSize();

      mScreenPoint.x = -1;
      mScreenPoint.y = -1;
      this.mPrevDrawnScreenPoint.x = -1;
      this.mPrevDrawnScreenPoint.y = -1;

      switch (mTrackColoringMethod) {
        case (DRAW_CALCULATED):
        case (DRAW_MEASURED):
        case (DRAW_RED):
        case (DRAW_GREEN):
          calculatePath();
          synchronized (mPath) // Switch the fresh path with the old Path object
          {
            Path oldPath = mPath;
            mPath = mPathCalculation;
            mPathCalculation = oldPath;
          }
          break;
        case (DRAW_DOTS):
          calculateDots();
          synchronized (mDotPath) // Switch the fresh path with the old Path object
          {
            Vector<DotVO> oldDotPath = mDotPath;
            mDotPath = mDotPathCalculation;
            mDotPathCalculation = oldDotPath;
          }
          break;
      }
      mLoggerMap.onDateOverlayChanged();
    }
  }
	/**
	 * draw icon.
	 *
	 * @param canvas  Canvas object.
	 * @param mapView MapView object.
	 * @param shadow  shadow flag.
	 */
	@Override
	public void draw(Canvas canvas, MapView mapView, boolean shadow) {
		cluster.onNotifyDrawFromMarker();
		Projection proj = mapView.getProjection();
		Point p = proj.toPixels(center, null);
		if (p.x < 0 || p.x > mapView.getWidth() || p.y < 0 || p.y > mapView.getHeight()) {
			return;
		}
		MarkerBitmap mkrBmp = markerIconBmps.get(markerTypes);
		Bitmap bmp = selected ? mkrBmp.getBitmapSelect() : mkrBmp.getBitmapNormal();
		Point grid = mkrBmp.getGrid();
		Point gridReal = new Point((int) (grid.x * screenDensity + 0.5f), (int) (grid.y * screenDensity + 0.5f));
		canvas.drawBitmap(bmp, p.x - gridReal.x, p.y - gridReal.y, paint);
		String caption = String.valueOf(geoItems.size());
		int x = p.x;
		int y = p.y - txtHeightOffset;
		canvas.drawText(caption, x, y, paint);
	}
  @Override
  protected void drawMyLocation(
      Canvas canvas, MapView mapView, Location lastFix, GeoPoint myLocation, long when) {

    accuracyPaint = new Paint();
    accuracyPaint.setAntiAlias(true);
    accuracyPaint.setStrokeWidth(2.0f);
    center = new Point();
    left = new Point();

    Projection projection = mapView.getProjection();
    double latitude = lastFix.getLatitude();
    double longitude = lastFix.getLongitude();
    float accuracy = lastFix.getAccuracy();

    float[] result = new float[1];

    Location.distanceBetween(latitude, longitude, latitude, longitude + 1, result);
    float longitudeLineDistance = result[0];

    GeoPoint leftGeo =
        new GeoPoint(
            (int) (latitude * 1e6), (int) ((longitude - accuracy / longitudeLineDistance) * 1e6));
    projection.toPixels(leftGeo, left);
    projection.toPixels(myLocation, center);
    int radius = center.x - left.x;

    accuracyPaint.setColor(0xff6666ff);
    accuracyPaint.setStyle(Style.STROKE);
    canvas.drawCircle(center.x, center.y, radius, accuracyPaint);

    accuracyPaint.setColor(0x186666ff);
    accuracyPaint.setStyle(Style.FILL);
    canvas.drawCircle(center.x, center.y, radius, accuracyPaint);

    mapView.getProjection().toPixels(myLocation, point);
    rect.left = point.x - slips[currSlip].getIntrinsicWidth() / 2;
    rect.top = point.y - slips[currSlip].getIntrinsicHeight() / 2;
    rect.right = point.x + slips[currSlip].getIntrinsicWidth() / 2;
    rect.bottom = point.y + slips[currSlip].getIntrinsicHeight() / 2;
    slips[currSlip].setBounds(rect);
    slips[currSlip].draw(canvas);
  }
 private void drawStartStopCircles() {
   Bitmap bitmap;
   if ((this.mPlacement == FIRST_SEGMENT || this.mPlacement == FIRST_SEGMENT + LAST_SEGMENT)
       && this.mStartPoint != null) {
     Point out = new Point();
     mProjection.toPixels(this.mStartPoint, out);
     mCalculatedPoints++;
     bitmap = BitmapFactory.decodeResource(this.mContext.getResources(), R.drawable.stip2);
     this.mCanvas.drawBitmap(bitmap, out.x - 8, out.y - 8, new Paint());
   }
   if ((this.mPlacement == LAST_SEGMENT || this.mPlacement == FIRST_SEGMENT + LAST_SEGMENT)
       && this.mEndPoint != null) {
     Point out = new Point();
     mProjection.toPixels(this.mEndPoint, out);
     mCalculatedPoints++;
     bitmap = BitmapFactory.decodeResource(this.mContext.getResources(), R.drawable.stip);
     this.mCanvas.drawBitmap(bitmap, out.x - 5, out.y - 5, new Paint());
   }
 }
Beispiel #21
0
  @Override
  public boolean draw(Canvas canvas, MapView mapView, boolean shadow, long when) {
    Projection projection = mapView.getProjection();
    if (shadow == false) {
      Paint paint = new Paint();
      paint.setAntiAlias(true);
      Point point = new Point();
      projection.toPixels(gp1, point);
      // mode=1&#65306;start
      if (mode == 1) {
        if (defaultColor == 999) paint.setColor(Color.BLUE);
        else paint.setColor(defaultColor);
        // start point
      }
      // mode=2&#65306;path
      else if (mode == 2) {
        if (defaultColor == 999) paint.setColor(Color.RED);
        else paint.setColor(defaultColor);
        Point point2 = new Point();
        projection.toPixels(gp2, point2);
        paint.setStrokeWidth(5);
        paint.setAlpha(120);
        canvas.drawLine(point.x, point.y, point2.x, point2.y, paint);

      }
      /* mode=3&#65306;end */
      else if (mode == 3) {
        /* the last path */

        if (defaultColor == 999) paint.setColor(Color.GREEN);
        else paint.setColor(defaultColor);
        Point point2 = new Point();
        projection.toPixels(gp2, point2);
        paint.setStrokeWidth(5);
        paint.setAlpha(120);
        canvas.drawLine(point.x, point.y, point2.x, point2.y, paint);
        /* end point */

      }
    }
    return super.draw(canvas, mapView, shadow, when);
  }
  public void draw(Canvas canvas, MapView mapView, boolean shadow) {
    if (shadow == false) {
      Projection projection = mapView.getProjection();

      int length = pathGeoPoints.length;
      projectedPoints = new float[length * 4]; // Make room for from.x, from.y, to.x, to.y
      for (int g = 0, p = 1; g < length; g++, p += 2) {
        pathPoints[g] = projection.toPixels(pathGeoPoints[g], null);

        if (g % 2 != 0) {
          projectedPoints[p] = pathPoints[g].y;
          projectedPoints[p - 1] = pathPoints[g].x;
          projectedPoints[p - 2] = pathPoints[g - 1].y;
          projectedPoints[p - 3] = pathPoints[g - 1].x;
        }
      }

      canvas.drawLines(projectedPoints, paint);
    }
  }
  @Override
  public boolean draw(Canvas canvas, MapView mapView, boolean shadow, long when) {
    Projection projection = mapView.getProjection();
    if (shadow == false) {
      GeoPoint gp = new GeoPoint((int) this.geoLatitude, (int) this.geoLongitude);
      /* 将Location转成Point对象 */
      Point point = new Point();
      projection.toPixels(gp, point);

      /* 设定笔刷 */
      Paint paint = new Paint();
      paint.setAntiAlias(true);

      /* 绘制Overlay */
      // canvas.drawOval(oval, paint);
      Bitmap bm = BitmapFactory.decodeResource(mapView.getResources(), this.drawableID);
      canvas.drawBitmap(bm, point.x, point.y, paint);
    }
    return super.draw(canvas, mapView, shadow, when);
  }
 @Override
 public void draw(Canvas canvas, MapView mapView, boolean shadow) {
   super.draw(canvas, mapView, shadow);
   Point locationPoint = new Point();
   Projection projection = mapView.getProjection();
   projection.toPixels(getGeopoint(), locationPoint);
   Paint containerPaint = new Paint();
   containerPaint.setAntiAlias(true);
   int containerX = locationPoint.x;
   int containerY = locationPoint.y;
   if (shadow) {
     containerX += CONTAINER_SHADOW_OFFSET;
     containerY += CONTAINER_SHADOW_OFFSET;
     containerPaint.setARGB(90, 0, 0, 0);
     canvas.drawCircle(containerX, containerY, CONTAINER_RADIUS, containerPaint);
   } else {
     containerPaint.setColor(Color.RED);
     canvas.drawCircle(containerX, containerY, CONTAINER_RADIUS, containerPaint);
   }
 }
  private boolean commonOnTap(GeoPoint tappedGeoPoint) {
    List<Uri> tappedUri = new Vector<Uri>();

    Point tappedPoint = new Point();
    mProjection.toPixels(tappedGeoPoint, tappedPoint);
    for (MediaVO media : mMediaPath) {
      if (media.x < tappedPoint.x
          && tappedPoint.x < media.x + media.w
          && media.y < tappedPoint.y
          && tappedPoint.y < media.y + media.h) {
        // Log.d( TAG, String.format( "Tapped at a (x,y) (%d,%d)", tappedPoint.x, tappedPoint.y ) );
        tappedUri.add(media.uri);
      }
    }
    if (tappedUri.size() > 0) {
      return handleMediaTapList(tappedUri);
    } else {
      if (mTrackColoringMethod == DRAW_DOTS) {
        DotVO tapped = null;
        synchronized (mDotPath) // Switch the fresh path with the old Path object
        {
          int w = 25;
          for (DotVO dot : mDotPath) {
            //                  Log.d( TAG, "Compare ("+dot.x+","+dot.y+") with tap
            // ("+tappedPoint.x+","+tappedPoint.y+")" );
            if (dot.x - w < tappedPoint.x
                && tappedPoint.x < dot.x + w
                && dot.y - w < tappedPoint.y
                && tappedPoint.y < dot.y + w) {
              if (tapped == null) {
                tapped = dot;
              } else {
                tapped =
                    dot.distanceTo(tappedPoint) < tapped.distanceTo(tappedPoint) ? dot : tapped;
              }
            }
          }
        }
        if (tapped != null) {
          DateFormat timeFormat =
              android.text.format.DateFormat.getTimeFormat(mLoggerMap.getApplicationContext());
          String timetxt = timeFormat.format(new Date(tapped.time));
          UnitsI18n units = new UnitsI18n(mLoggerMap, null);
          double speed = units.conversionFromMetersPerSecond(tapped.speed);
          String speedtxt = String.format("%.1f %s", speed, units.getSpeedUnit());
          String text = mLoggerMap.getString(R.string.time_and_speed, timetxt, speedtxt);
          Toast toast = Toast.makeText(mLoggerMap, text, Toast.LENGTH_SHORT);
          toast.show();
        }
      }
      return false;
    }
  }
  @Override
  public void draw(Canvas canvas, MapView mapView, boolean shadow) {
    Projection projection = mapView.getProjection();

    // Create and setup your paint brush
    Paint paint = new Paint();
    paint.setARGB(250, 255, 0, 0);
    paint.setAntiAlias(true);
    paint.setFakeBoldText(true);

    if (shadow == false) {
      for (GeoPoint point : quakeLocations) {
        Point myPoint = new Point();
        projection.toPixels(point, myPoint);

        RectF oval = new RectF(myPoint.x - rad, myPoint.y - rad, myPoint.x + rad, myPoint.y + rad);

        canvas.drawOval(oval, paint);
      }
    }
  }
Beispiel #27
0
 public List<Point> convertListGeoPointToPoint(List<GeoPoint> listGeoPoint, Projection project) {
   List<Point> listPoint = new ArrayList<Point>();
   if (listGeoPoint != null && listGeoPoint.size() > 0 && project != null) {
     listPoint.clear();
     for (GeoPoint geoPoint : listGeoPoint) {
       Point point = new Point();
       project.toPixels(geoPoint, point);
       listPoint.add(point);
     }
   }
   return listPoint;
 }
  /**
   * @param canvas
   * @param mapView
   * @param shadow
   * @see TrackingOverlay#draw(Canvas, MapView, boolean)
   */
  public void drawPath(Canvas canvas, MapView mapView, boolean shadow) {
    this.mCanvas = canvas;
    this.mScreenPoint = new Point();
    this.mPrevScreenPoint = new Point();
    mProjection = mapView.getProjection();
    mTopLeft = mProjection.fromPixels(0, 0);
    mBottumRight = mProjection.fromPixels(this.mCanvas.getWidth(), this.mCanvas.getHeight());

    this.mPath.rewind();
    this.mShader = null;
    transformSegmentToPath();

    // Just the rendering bits left to do
    Paint routePaint = new Paint();
    routePaint.setPathEffect(new CornerPathEffect(10));
    //      Log.d( TAG, "Drawing color is "+trackColoringMethod );
    switch (trackColoringMethod) {
      case (DRAW_CALCULATED):
      case (DRAW_MEASURED):
        routePaint.setShader(this.mShader);
        break;
      case (DRAW_RED):
        routePaint.setColor(Color.RED);
        break;
      case (DRAW_GREEN):
      default:
        routePaint.setColor(Color.GREEN);
        break;
    }
    routePaint.setStyle(Paint.Style.STROKE);
    routePaint.setStrokeWidth(8);
    routePaint.setAntiAlias(true);

    this.mCanvas.drawPath(this.mPath, routePaint);

    drawStartStopCircles();

    super.draw(this.mCanvas, mapView, shadow);
    this.mCanvas = null;
  }
Beispiel #29
0
  @Override
  public boolean onTap(GeoPoint p, MapView mapView) {
    if (isTapable()) {
      Footprint chosen = null;
      // TODO calculate tapped Footprint

      System.out.println("--------------> TAB TAB TAB TAB");
      if (activity.footprints != null) {
        iterator = activity.footprints.iterator();
      }

      while (iterator != null && iterator.hasNext()) {
        Footprint footprint = iterator.next();
        GeoPoint geoPoint = footprint.getLocation();

        Point p_foot = new Point();
        Point p_tab = new Point();

        projection.toPixels(geoPoint, p_foot);
        projection.toPixels(p, p_tab);

        if (p_tab.x >= p_foot.x
            & p_tab.y >= p_foot.y
            & p_tab.x <= (p_foot.x + 45)
            & p_tab.y <= (p_foot.y + 45)) {
          chosen = footprint;
          break;
        }
      }

      if (chosen != null) {
        activity.activateFotoView(chosen);
      }
    }
    return super.onTap(p, mapView);
  }
Beispiel #30
0
  /** ***** Overlay Overrides ****** */
  @Override
  public void draw(Canvas canvas, MapView mapView, boolean shadow) {
    super.draw(canvas, mapView, shadow);

    final Projection projection = mapView.getProjection();

    int numPoints = points.size();

    if (numPoints > 1) {
      for (int i = 0; i < points.size() - 1; i++) {
        GeoPoint gp1 = points.get(i);
        GeoPoint gp2 = points.get(i + 1);
        Paint paint = new Paint();
        paint.setDither(true);
        paint.setColor(Color.RED);
        paint.setStyle(Paint.Style.FILL_AND_STROKE);
        paint.setStrokeJoin(Paint.Join.ROUND);
        paint.setStrokeCap(Paint.Cap.ROUND);
        paint.setStrokeWidth(4);
        paint.setAlpha(80);

        Point p1 = new Point();
        Point p2 = new Point();

        Path path = new Path();

        projection.toPixels(gp1, p1);
        projection.toPixels(gp2, p2);

        path.moveTo(p2.x, p2.y);
        path.lineTo(p1.x, p1.y);

        canvas.drawPath(path, paint);
      }
    }
  }