コード例 #1
0
ファイル: OsmandRenderer.java プロジェクト: Flocki1982/Osmand
  private void drawPolygon(
      BinaryMapDataObject obj,
      RenderingRuleSearchRequest render,
      Canvas canvas,
      RenderingContext rc,
      TagValuePair pair) {
    if (render == null || pair == null) {
      return;
    }
    float xText = 0;
    float yText = 0;
    int zoom = rc.zoom;
    Path path = null;

    // rc.main.color = Color.rgb(245, 245, 245);
    render.setInitialTagValueZoom(pair.tag, pair.value, zoom, obj);
    boolean rendered = render.search(RenderingRulesStorage.POLYGON_RULES);
    if (!rendered || !updatePaint(render, paint, 0, true, rc)) {
      return;
    }
    rc.visible++;
    int len = obj.getPointsLength();
    for (int i = 0; i < obj.getPointsLength(); i++) {

      PointF p = calcPoint(obj, i, rc);
      xText += p.x;
      yText += p.y;
      if (path == null) {
        path = new Path();
        path.moveTo(p.x, p.y);
      } else {
        path.lineTo(p.x, p.y);
      }
    }
    int[][] polygonInnerCoordinates = obj.getPolygonInnerCoordinates();
    if (polygonInnerCoordinates != null && path != null) {
      path.setFillType(FillType.EVEN_ODD);
      for (int j = 0; j < polygonInnerCoordinates.length; j++) {
        for (int i = 0; i < polygonInnerCoordinates[j].length; i += 2) {
          PointF p =
              calcPoint(polygonInnerCoordinates[j][i], polygonInnerCoordinates[j][i + 1], rc);
          if (i == 0) {
            path.moveTo(p.x, p.y);
          } else {
            path.lineTo(p.x, p.y);
          }
        }
      }
    }

    if (path != null && len > 0) {
      canvas.drawPath(path, paint);
      if (updatePaint(render, paint, 1, false, rc)) {
        canvas.drawPath(path, paint);
      }
      textRenderer.renderText(obj, render, rc, pair, xText / len, yText / len, null, null);
    }
  }
コード例 #2
0
ファイル: OsmandRenderer.java プロジェクト: Flocki1982/Osmand
  private TIntObjectHashMap<TIntArrayList> sortObjectsByProperOrder(
      RenderingContext rc, List<BinaryMapDataObject> objects, RenderingRuleSearchRequest render) {
    int sz = objects.size();
    TIntObjectHashMap<TIntArrayList> orderMap = new TIntObjectHashMap<TIntArrayList>();
    if (render != null) {
      render.clearState();

      for (int i = 0; i < sz; i++) {
        BinaryMapDataObject o = objects.get(i);
        int sh = i << 8;

        for (int j = 0; j < o.getTypes().length; j++) {
          // put(orderMap, BinaryMapDataObject.getOrder(o.getTypes()[j]), sh + j, init);
          int wholeType = o.getTypes()[j];

          int layer = 0;
          if (o.getPointsLength() > 1) {
            layer = o.getSimpleLayer();
          }

          TagValuePair pair = o.getMapIndex().decodeType(wholeType);
          if (pair != null) {
            render.setTagValueZoomLayer(pair.tag, pair.value, rc.zoom, layer, o);
            render.setBooleanFilter(render.ALL.R_AREA, o.isArea());
            render.setBooleanFilter(render.ALL.R_POINT, o.getPointsLength() == 1);
            render.setBooleanFilter(render.ALL.R_CYCLE, o.isCycle());
            if (render.search(RenderingRulesStorage.ORDER_RULES)) {
              int objectType = render.getIntPropertyValue(render.ALL.R_OBJECT_TYPE);
              int order = render.getIntPropertyValue(render.ALL.R_ORDER);
              put(orderMap, (order << 2) | objectType, sh + j);
              if (objectType == 3) {
                // add icon point all the time
                put(orderMap, (128 << 2) | 1, sh + j);
              }
              if (render.isSpecified(render.ALL.R_SHADOW_LEVEL)) {
                rc.shadowLevelMin = Math.min(rc.shadowLevelMin, order);
                rc.shadowLevelMax = Math.max(rc.shadowLevelMax, order);
                render.clearValue(render.ALL.R_SHADOW_LEVEL);
              }
            }
          }
        }

        if (rc.interrupted) {
          return orderMap;
        }
      }
    }
    return orderMap;
  }
コード例 #3
0
ファイル: OsmandRenderer.java プロジェクト: Flocki1982/Osmand
  private void drawPoint(
      BinaryMapDataObject obj,
      RenderingRuleSearchRequest render,
      Canvas canvas,
      RenderingContext rc,
      TagValuePair pair,
      boolean renderText) {
    if (render == null || pair == null) {
      return;
    }
    render.setInitialTagValueZoom(pair.tag, pair.value, rc.zoom, obj);
    render.search(RenderingRulesStorage.POINT_RULES);

    String resId = render.getStringPropertyValue(render.ALL.R_ICON);
    if (resId == null && !renderText) {
      return;
    }
    int len = obj.getPointsLength();
    rc.visible++;
    PointF ps = new PointF(0, 0);
    for (int i = 0; i < len; i++) {
      PointF p = calcPoint(obj, i, rc);
      ps.x += p.x;
      ps.y += p.y;
    }
    if (len > 1) {
      ps.x /= len;
      ps.y /= len;
    }

    if (resId != null) {
      IconDrawInfo ico = new IconDrawInfo();
      ico.x = ps.x;
      ico.y = ps.y;
      ico.resId = resId;
      rc.iconsToDraw.add(ico);
    }
    if (renderText) {
      textRenderer.renderText(obj, render, rc, pair, ps.x, ps.y, null, null);
    }
  }
コード例 #4
0
ファイル: TextRenderer.java プロジェクト: quorry/Osmand
 private void createTextDrawInfo(
     BinaryMapDataObject o,
     RenderingRuleSearchRequest render,
     RenderingContext rc,
     TagValuePair pair,
     float xMid,
     float yMid,
     Path path,
     PointF[] points,
     String name,
     String tagName) {
   render.setInitialTagValueZoom(pair.tag, pair.value, rc.zoom, o);
   render.setIntFilter(render.ALL.R_TEXT_LENGTH, name.length());
   render.setStringFilter(render.ALL.R_NAME_TAG, tagName);
   if (render.search(RenderingRulesStorage.TEXT_RULES)) {
     if (render.getIntPropertyValue(render.ALL.R_TEXT_SIZE) > 0) {
       TextDrawInfo text = new TextDrawInfo(name);
       text.fillProperties(render, xMid, yMid);
       paintText.setTextSize(rc.getDensityValue(text.textSize));
       Rect bs = new Rect();
       paintText.getTextBounds(name, 0, name.length(), bs);
       text.bounds = new RectF(bs);
       text.bounds.inset(-rc.getDensityValue(3), -rc.getDensityValue(10));
       boolean display = true;
       if (path != null) {
         text.drawOnPath = path;
         display =
             calculatePathToRotate(
                 rc, text, points, render.getIntPropertyValue(render.ALL.R_TEXT_ON_PATH, 0) != 0);
       }
       if (text.drawOnPath == null) {
         text.bounds.offset(text.centerX, text.centerY);
         // shift to match alignment
         text.bounds.offset(-text.bounds.width() / 2, 0);
       } else {
         text.bounds.offset(
             text.centerX - text.bounds.width() / 2, text.centerY - text.bounds.height() / 2);
       }
       if (display) {
         rc.textToDraw.add(text);
       }
     }
   }
 }
コード例 #5
0
ファイル: TextRenderer.java プロジェクト: quorry/Osmand
 public void fillProperties(RenderingRuleSearchRequest render, float centerX, float centerY) {
   this.centerX = centerX;
   this.centerY = centerY + render.getIntPropertyValue(render.ALL.R_TEXT_DY, 0);
   // used only for draw on path where centerY doesn't play role
   this.vOffset = render.getIntPropertyValue(render.ALL.R_TEXT_DY, 0);
   textColor = render.getIntPropertyValue(render.ALL.R_TEXT_COLOR);
   if (textColor == 0) {
     textColor = Color.BLACK;
   }
   textSize = render.getIntPropertyValue(render.ALL.R_TEXT_SIZE);
   textShadow = render.getIntPropertyValue(render.ALL.R_TEXT_HALO_RADIUS, 0);
   textWrap = render.getIntPropertyValue(render.ALL.R_TEXT_WRAP_WIDTH, 0);
   bold = render.getIntPropertyValue(render.ALL.R_TEXT_BOLD, 0) > 0;
   minDistance = render.getIntPropertyValue(render.ALL.R_TEXT_MIN_DISTANCE, 0);
   if (render.isSpecified(render.ALL.R_TEXT_SHIELD)) {
     shieldRes = render.getStringPropertyValue(render.ALL.R_TEXT_SHIELD);
   }
   textOrder = render.getIntPropertyValue(render.ALL.R_TEXT_ORDER, 100);
 }
コード例 #6
0
ファイル: OsmandRenderer.java プロジェクト: Flocki1982/Osmand
  private void drawPolyline(
      BinaryMapDataObject obj,
      RenderingRuleSearchRequest render,
      Canvas canvas,
      RenderingContext rc,
      TagValuePair pair,
      int layer,
      boolean drawOnlyShadow) {
    if (render == null || pair == null) {
      return;
    }
    int length = obj.getPointsLength();
    if (length < 2) {
      return;
    }
    render.setInitialTagValueZoom(pair.tag, pair.value, rc.zoom, obj);
    render.setIntFilter(render.ALL.R_LAYER, layer);
    boolean rendered = render.search(RenderingRulesStorage.LINE_RULES);
    if (!rendered || !updatePaint(render, paint, 0, false, rc)) {
      return;
    }
    int oneway = 0;
    if (rc.zoom >= 16 && "highway".equals(pair.tag)) { // $NON-NLS-1$
      if (obj.containsAdditionalType(obj.getMapIndex().onewayAttribute)) {
        oneway = 1;
      } else if (obj.containsAdditionalType(obj.getMapIndex().onewayReverseAttribute)) {
        oneway = -1;
      }
    }

    rc.visible++;

    Path path = null;
    float xMid = 0;
    float yMid = 0;
    int middle = obj.getPointsLength() / 2;
    PointF[] textPoints = null;
    if (!drawOnlyShadow) {
      textPoints = new PointF[length];
    }

    for (int i = 0; i < length; i++) {
      PointF p = calcPoint(obj, i, rc);
      if (textPoints != null) {
        textPoints[i] = new PointF(p.x, p.y);
      }
      if (path == null) {
        path = new Path();
        path.moveTo(p.x, p.y);
      } else {
        if (i == middle) {
          xMid = p.x;
          yMid = p.y;
        }
        path.lineTo(p.x, p.y);
      }
    }
    if (path != null) {
      if (drawOnlyShadow) {
        int shadowColor = render.getIntPropertyValue(render.ALL.R_SHADOW_COLOR);
        int shadowRadius = render.getIntPropertyValue(render.ALL.R_SHADOW_RADIUS);
        if (shadowColor == 0) {
          shadowColor = rc.shadowRenderingColor;
        }
        drawPolylineShadow(canvas, rc, path, shadowColor, shadowRadius);
      } else {
        boolean update = false;
        if (updatePaint(render, paint, -2, false, rc)) {
          update = true;
          canvas.drawPath(path, paint);
        }
        if (updatePaint(render, paint, -1, false, rc)) {
          update = true;
          canvas.drawPath(path, paint);
        }
        if (update) {
          updatePaint(render, paint, 0, false, rc);
        }
        canvas.drawPath(path, paint);
        if (updatePaint(render, paint, 1, false, rc)) {
          canvas.drawPath(path, paint);
        }
        if (updatePaint(render, paint, 2, false, rc)) {
          canvas.drawPath(path, paint);
        }
      }

      if (oneway != 0 && !drawOnlyShadow) {
        Paint[] paints = oneway == -1 ? getReverseOneWayPaints() : getOneWayPaints();
        for (int i = 0; i < paints.length; i++) {
          canvas.drawPath(path, paints[i]);
        }
      }
      if (textPoints != null) {
        textRenderer.renderText(obj, render, rc, pair, xMid, yMid, path, textPoints);
      }
    }
  }
コード例 #7
0
ファイル: OsmandRenderer.java プロジェクト: Flocki1982/Osmand
  private boolean updatePaint(
      RenderingRuleSearchRequest req, Paint p, int ind, boolean area, RenderingContext rc) {
    RenderingRuleProperty rColor;
    RenderingRuleProperty rStrokeW;
    RenderingRuleProperty rCap;
    RenderingRuleProperty rPathEff;

    if (ind == 0) {
      rColor = req.ALL.R_COLOR;
      rStrokeW = req.ALL.R_STROKE_WIDTH;
      rCap = req.ALL.R_CAP;
      rPathEff = req.ALL.R_PATH_EFFECT;
    } else if (ind == 1) {
      rColor = req.ALL.R_COLOR_2;
      rStrokeW = req.ALL.R_STROKE_WIDTH_2;
      rCap = req.ALL.R_CAP_2;
      rPathEff = req.ALL.R_PATH_EFFECT_2;
    } else if (ind == -1) {
      rColor = req.ALL.R_COLOR_0;
      rStrokeW = req.ALL.R_STROKE_WIDTH_0;
      rCap = req.ALL.R_CAP_0;
      rPathEff = req.ALL.R_PATH_EFFECT_0;
    } else if (ind == -2) {
      rColor = req.ALL.R_COLOR__1;
      rStrokeW = req.ALL.R_STROKE_WIDTH__1;
      rCap = req.ALL.R_CAP__1;
      rPathEff = req.ALL.R_PATH_EFFECT__1;
    } else {
      rColor = req.ALL.R_COLOR_3;
      rStrokeW = req.ALL.R_STROKE_WIDTH_3;
      rCap = req.ALL.R_CAP_3;
      rPathEff = req.ALL.R_PATH_EFFECT_3;
    }
    if (area) {
      if (!req.isSpecified(rColor) && !req.isSpecified(req.ALL.R_SHADER)) {
        return false;
      }
      p.setShader(null);
      p.setColorFilter(null);
      p.clearShadowLayer();
      p.setStyle(Style.FILL_AND_STROKE);
      p.setStrokeWidth(0);
    } else {
      if (!req.isSpecified(rStrokeW)) {
        return false;
      }
      p.setShader(null);
      p.setColorFilter(null);
      p.clearShadowLayer();
      p.setStyle(Style.STROKE);
      p.setStrokeWidth(req.getFloatPropertyValue(rStrokeW));
      String cap = req.getStringPropertyValue(rCap);
      if (!Algoritms.isEmpty(cap)) {
        p.setStrokeCap(Cap.valueOf(cap.toUpperCase()));
      } else {
        p.setStrokeCap(Cap.BUTT);
      }
      String pathEffect = req.getStringPropertyValue(rPathEff);
      if (!Algoritms.isEmpty(pathEffect)) {
        p.setPathEffect(getDashEffect(pathEffect));
      } else {
        p.setPathEffect(null);
      }
    }
    p.setColor(req.getIntPropertyValue(rColor));
    if (ind == 0) {
      String resId = req.getStringPropertyValue(req.ALL.R_SHADER);
      if (resId != null) {
        p.setShader(getShader(resId));
      }
      // do not check shadow color here
      if (rc.shadowRenderingMode == 1) {
        int shadowColor = req.getIntPropertyValue(req.ALL.R_SHADOW_COLOR);
        if (shadowColor == 0) {
          shadowColor = rc.shadowRenderingColor;
        }
        int shadowLayer = req.getIntPropertyValue(req.ALL.R_SHADOW_RADIUS);
        if (shadowColor == 0) {
          shadowLayer = 0;
        }
        p.setShadowLayer(shadowLayer, 0, 0, shadowColor);
      }
    }

    return true;
  }