Java Code Examples for android.graphics.Path#transform()

@Override
public boolean doTextContainer(TextContainer obj)
{
   if (obj instanceof SVG.TextPath)
   {
      // Since we cheat a bit with our textPath rendering, we need
      // to cheat a bit with our bbox calculation.
      SVG.TextPath  tpath = (SVG.TextPath) obj;
      SVG.SvgObject  ref = obj.document.resolveIRI(tpath.href);
      if (ref == null) {
         error("TextPath path reference '%s' not found", tpath.href);
         return false;
      }
      SVG.Path  pathObj = (SVG.Path) ref;
      Path      path = (new PathConverter(pathObj.d)).getPath();
      if (pathObj.transform != null)
         path.transform(pathObj.transform);
      RectF     pathBounds = new RectF();
      path.computeBounds(pathBounds, true);
      bbox.union(pathBounds);
      return false;
   }
   return true;
}
 

@Override
public boolean hitTestForSelection(Path path) {
    if (!isSelectionEnabled()) {
        return false;
    }

    RectF box = new RectF();
    if (path.isRect(box)) {
        // Quick check if path is rectangle
        return box.contains(getOuterBoundingBox());
    } else {
        path.transform(getInvertedDisplayMatrix());
        Region r1 = ShapeUtils.createRegionFromPath(path);
        Region r2 = ShapeUtils.createRegionFromPath(getTouchableArea());
        if (r1.quickReject(r2)) {
            // Quick check for not intersect case
            return false;
        }
        return !r2.op(r1, Region.Op.DIFFERENCE);
    }
}
 

private void computePath(Rect bounds) {
    final float currentScale = mCurrentScale;
    final Path path = mPath;
    final RectF rect = mRect;
    final Matrix matrix = mMatrix;

    path.reset();
    int totalSize = Math.min(bounds.width(), bounds.height());

    float initial = mClosedStateSize;
    float destination = totalSize;
    float currentSize = initial + (destination - initial) * currentScale;

    float halfSize = currentSize / 2f;
    float inverseScale = 1f - currentScale;
    float cornerSize = halfSize * inverseScale;
    float[] corners = new float[]{halfSize, halfSize, halfSize, halfSize, halfSize, halfSize, cornerSize, cornerSize};
    rect.set(bounds.left, bounds.top, bounds.left + currentSize, bounds.top + currentSize);
    path.addRoundRect(rect, corners, Path.Direction.CCW);
    matrix.reset();
    matrix.postRotate(-45, bounds.left + halfSize, bounds.top + halfSize);
    matrix.postTranslate((bounds.width() - currentSize) / 2, 0);
    float hDiff = (bounds.bottom - currentSize - mExternalOffset) * inverseScale;
    matrix.postTranslate(0, hDiff);
    path.transform(matrix);
}
 

private void computePath(Rect bounds) {
    final float currentScale = mCurrentScale;
    final Path path = mPath;
    final RectF rect = mRect;
    final Matrix matrix = mMatrix;

    path.reset();
    int totalSize = Math.min(bounds.width(), bounds.height());

    float initial = mClosedStateSize;
    float destination = totalSize;
    float currentSize = initial + (destination - initial) * currentScale;

    float halfSize = currentSize / 2f;
    float inverseScale = 1f - currentScale;
    float cornerSize = halfSize * inverseScale;
    float[] corners = new float[]{halfSize, halfSize, halfSize, halfSize, halfSize, halfSize, cornerSize, cornerSize};
    rect.set(bounds.left, bounds.top, bounds.left + currentSize, bounds.top + currentSize);
    path.addRoundRect(rect, corners, Path.Direction.CCW);
    matrix.reset();
    matrix.postRotate(-45, bounds.left + halfSize, bounds.top + halfSize);
    matrix.postTranslate((bounds.width() - currentSize) / 2, 0);
    float hDiff = (bounds.bottom - currentSize - mExternalOffset) * inverseScale;
    matrix.postTranslate(0, hDiff);
    path.transform(matrix);
}
 

@Override
public boolean doTextContainer(TextContainer obj)
{
   if (obj instanceof SVG.TextPath)
   {
      // Since we cheat a bit with our textPath rendering, we need
      // to cheat a bit with our bbox calculation.
      SVG.TextPath  tpath = (SVG.TextPath) obj;
      SVG.SvgObject  ref = obj.document.resolveIRI(tpath.href);
      if (ref == null) {
         error("TextPath path reference '%s' not found", tpath.href);
         return false;
      }
      SVG.Path  pathObj = (SVG.Path) ref;
      Path      path = (new PathConverter(pathObj.d)).getPath();
      if (pathObj.transform != null)
         path.transform(pathObj.transform);
      RectF     pathBounds = new RectF();
      path.computeBounds(pathBounds, true);
      bbox.union(pathBounds);
      return false;
   }
   return true;
}
 

private void computePath(Rect bounds) {
    final float currentScale = mCurrentScale;
    final Path path = mPath;
    final RectF rect = mRect;
    final Matrix matrix = mMatrix;

    path.reset();
    int totalSize = Math.min(bounds.width(), bounds.height());

    float initial = mClosedStateSize;
    float destination = totalSize;
    float currentSize = initial + (destination - initial) * currentScale;

    float halfSize = currentSize / 2f;
    float inverseScale = 1f - currentScale;
    float cornerSize = halfSize * inverseScale;
    float[] corners = new float[]{halfSize, halfSize, halfSize, halfSize, halfSize, halfSize, cornerSize, cornerSize};
    rect.set(bounds.left, bounds.top, bounds.left + currentSize, bounds.top + currentSize);
    path.addRoundRect(rect, corners, Path.Direction.CCW);
    matrix.reset();
    matrix.postRotate(-45, bounds.left + halfSize, bounds.top + halfSize);
    matrix.postTranslate((bounds.width() - currentSize) / 2, 0);
    float hDiff = (bounds.bottom - currentSize - mExternalOffset) * inverseScale;
    matrix.postTranslate(0, hDiff);
    path.transform(matrix);
}
 

@Override
public void applyToPath(@NonNull Matrix transform, @NonNull Path path) {
  Matrix inverse = matrix;
  transform.invert(inverse);
  path.transform(inverse);
  path.lineTo(x, y);
  path.transform(transform);
}
 

public void fillPath(Path p) {
    paint.setStyle(Paint.Style.FILL);

    if (getTransform().isIdentity()) {
        canvas.drawPath(p, paint);
    } else {
        RectF bounds = new RectF();
        p.computeBounds(bounds, false);
        Path p2 = new Path();
        p.transform(getTransformMatrix(), p2);
        RectF bounds2 = new RectF();
        p2.computeBounds(bounds2, false);
        float ratio = Math.max(bounds2.width()/bounds.width(), bounds2.height()/bounds.height());
        if (ratio > 2 && !isMutableImageGraphics) {
            // If the canvas is hardware accelerated, then it will rasterize the path
            // first, then apply the transform which leads to blurry paths if the transform does
            // significant scaling.
            // In such cases, we
            Bitmap nativeBuffer = Bitmap.createBitmap(
                    (int)(bounds2.width()), (int)(bounds2.height()), Bitmap.Config.ARGB_8888);
            //int restorePoint = canvas.saveLayer(bounds2, paint, Canvas.ALL_SAVE_FLAG);
            Canvas c = new Canvas(nativeBuffer);
            Matrix translateM = new Matrix();
            translateM.set(getTransformMatrix());
            translateM.postTranslate(-bounds2.left, -bounds2.top);
            c.concat(translateM);
            c.drawPath(p, paint);
            canvas.drawBitmap(nativeBuffer, bounds2.left, bounds2.top, paint);

        } else {
            canvas.save();
            applyTransform();
            canvas.drawPath(p, paint);
            unapplyTransform();
            canvas.restore();
        }
    }

}
 

@Override
protected void calculateBoundingBox() {
    Rect box = new Rect();
    paint.getTextBounds(text, 0, text.length(), box);
    originalBoundingBox = new RectF(box);
    boundingPath = new Path();
    boundingPath.addRect(originalBoundingBox, Path.Direction.CW);
    boundingPath.transform(dataMatrix);
    updateBoundingBox();
}
 

/**
 * transform a path with all the given matrices VERY IMPORTANT: keep order
 * to value-touch-offset
 * 
 * @param path
 */
protected void transformPath(Path path) {

    path.transform(mMatrixValueToPx);
    path.transform(mMatrixTouch);
    path.transform(mMatrixOffset);
}
 

/**
 * Sets the Path defining a pattern of motion between two coordinates.
 * The pattern will be translated, rotated, and scaled to fit between the start and end points.
 * The pattern must not be empty and must have the end point differ from the start point.
 *
 * @param patternPath A Path to be used as a pattern for two-dimensional motion.
 * @attr ref android.R.styleable#PatternPathMotion_patternPathData
 */
public void setPatternPath(Path patternPath) {
    PathMeasure pathMeasure = new PathMeasure(patternPath, false);
    float length = pathMeasure.getLength();
    float[] pos = new float[2];
    pathMeasure.getPosTan(length, pos, null);
    float endX = pos[0];
    float endY = pos[1];
    pathMeasure.getPosTan(0, pos, null);
    float startX = pos[0];
    float startY = pos[1];

    if (startX == endX && startY == endY) {
        throw new IllegalArgumentException("pattern must not end at the starting point");
    }

    mTempMatrix.setTranslate(-startX, -startY);
    float dx = endX - startX;
    float dy = endY - startY;
    float distance = (float) Math.hypot(dx, dy);
    float scale = 1 / distance;
    mTempMatrix.postScale(scale, scale);
    double angle = Math.atan2(dy, dx);
    mTempMatrix.postRotate((float) Math.toDegrees(-angle));
    patternPath.transform(mTempMatrix, mPatternPath);
    mOriginalPatternPath = patternPath;
}
 

/**
 * transform a path with all the given matrices VERY IMPORTANT: keep order
 * to value-touch-offset
 * 
 * @param path
 */
protected void transformPath(Path path) {

    path.transform(mMatrixValueToPx);
    path.transform(mMatrixTouch);
    path.transform(mMatrixOffset);
}
 

/**
 * Returns if the shape of the icon is same as the path.
 * For this method to work, the shape path bounds should be in [0,1]x[0,1] bounds.
 */
private boolean isShape(Path maskPath) {
    // Condition1:
    // If width and height of the path not close to a square, then the icon shape is
    // not same as the mask shape.
    float iconRatio = ((float) mBounds.width()) / mBounds.height();
    if (Math.abs(iconRatio - 1) > BOUND_RATIO_MARGIN) {
        return false;
    }

    // Condition 2:
    // Actual icon (white) and the fitted shape (e.g., circle)(red) XOR operation
    // should generate transparent image, if the actual icon is equivalent to the shape.
    mFileId = mRandom.nextInt();
    mBitmapARGB.eraseColor(Color.TRANSPARENT);
    mCanvasARGB.drawBitmap(mBitmap, 0, 0, mPaintIcon);

    // Fit the shape within the icon's bounding box
    mMatrix.reset();
    mMatrix.setScale(mBounds.width(), mBounds.height());
    mMatrix.postTranslate(mBounds.left, mBounds.top);
    maskPath.transform(mMatrix);

    // XOR operation
    mCanvasARGB.drawPath(maskPath, mPaintMaskShape);

    // DST_OUT operation around the mask path outline
    mCanvasARGB.drawPath(maskPath, mPaintMaskShapeOutline);

    boolean isTrans = isTransparentBitmap(mBitmapARGB);

    // Check if the result is almost transparent
    if (!isTrans) {
        return false;
    }
    return true;
}
 

/**
 * Sets the Path defining a pattern of motion between two coordinates.
 * The pattern will be translated, rotated, and scaled to fit between the start and end points.
 * The pattern must not be empty and must have the end point differ from the start point.
 *
 * @param patternPath A Path to be used as a pattern for two-dimensional motion.
 * @attr ref android.R.styleable#PatternPathMotion_patternPathData
 */
public void setPatternPath(@Nullable Path patternPath) {
    PathMeasure pathMeasure = new PathMeasure(patternPath, false);
    float length = pathMeasure.getLength();
    float[] pos = new float[2];
    pathMeasure.getPosTan(length, pos, null);
    float endX = pos[0];
    float endY = pos[1];
    pathMeasure.getPosTan(0, pos, null);
    float startX = pos[0];
    float startY = pos[1];

    if (startX == endX && startY == endY) {
        throw new IllegalArgumentException("pattern must not end at the starting point");
    }

    mTempMatrix.setTranslate(-startX, -startY);
    float dx = endX - startX;
    float dy = endY - startY;
    float distance = (float) Math.hypot(dx, dy);
    float scale = 1 / distance;
    mTempMatrix.postScale(scale, scale);
    double angle = Math.atan2(dy, dx);
    mTempMatrix.postRotate((float) Math.toDegrees(-angle));
    if (patternPath != null) {
        patternPath.transform(mTempMatrix, mPatternPath);
    }
    mOriginalPatternPath = patternPath;
}
 

@Override
public RectF getOuterBoundingBox() {
    if (boundingPath != null) {
        Path path = new Path(boundingPath);
        path.transform(getDisplayMatrix());
        RectF box = new RectF();
        path.computeBounds(box, true);
        return box;
    }
    return new RectF();
}
 

/**
 * transform a path with all the given matrices VERY IMPORTANT: keep order
 * to value-touch-offset
 *
 * @param path
 */
public void pathValueToPixel(Path path) {

    path.transform(mMatrixValueToPx);
    path.transform(mViewPortHandler.getMatrixTouch());
    path.transform(mMatrixOffset);
}
 

@Override
public void applyToPath(@NonNull Matrix transform, @NonNull Path path) {
  Matrix inverse = matrix;
  transform.invert(inverse);
  path.transform(inverse);
  path.cubicTo(controlX1, controlY1, controlX2, controlY2, endX, endY);
  path.transform(transform);
}
 

public static Path getTwoCircle_CutLineMergePath(Circle c1, Circle c2, double expandAngel) {
    float startAngel = GeometryUtils.getP2AngleByX(c2.center, c1.center);
    Matrix m = new Matrix();
    float[] src = new float[]{c2.center.x, c2.center.y};
    float[] dst = new float[2];//代替了c2.center的点
    m.postRotate(-startAngel, c1.center.x, c1.center.y); //现在都在右边了
    m.mapPoints(dst, src);
    //现在为止   就是 c1,c2 x点都是相同了 并且 c2在c1右边
    ZPointF pA, pB, pC, pD;//AD 在c1,  BC在c2上
    ZPointF pApDControl, pBpCControl;//AD 在c1,  BC在c2上

    pA = new ZPointF((float) Math.cos(Math.toRadians(expandAngel / 2)) * c1.r, -(float) Math.sin(Math.toRadians(expandAngel / 2)) * c1.r);
    pA.offset(c1.center);

    pD = new ZPointF((float) Math.cos(Math.toRadians(expandAngel / 2)) * c1.r, (float) Math.sin(Math.toRadians(expandAngel / 2)) * c1.r);
    pD.offset(c1.center);

    pApDControl = new ZPointF((float) (c1.r / Math.cos(Math.toRadians(expandAngel / 2))), 0);
    pApDControl.offset(c1.center);

    pB = new ZPointF(-(float) Math.cos(Math.toRadians(expandAngel / 2)) * c2.r, -(float) Math.sin(Math.toRadians(expandAngel / 2)) * c2.r);
    pB.offset(dst[0], dst[1]);

    pC = new ZPointF(-(float) Math.cos(Math.toRadians(expandAngel / 2)) * c2.r, (float) Math.sin(Math.toRadians(expandAngel / 2)) * c2.r);
    pC.offset(dst[0], dst[1]);

    pBpCControl = new ZPointF(-(float) (c2.r / Math.cos(Math.toRadians(expandAngel / 2))), 0);
    pBpCControl.offset(dst[0], dst[1]);

    Path resultPath = new Path();
    resultPath.moveTo(pA.x, pA.y);
    resultPath.cubicTo(pApDControl.x, pApDControl.y, pBpCControl.x, pBpCControl.y, pB.x, pB.y);
    resultPath.lineTo(pC.x, pC.y);
    resultPath.cubicTo(pBpCControl.x, pBpCControl.y, pApDControl.x, pApDControl.y, pD.x, pD.y);
    resultPath.close();

    Matrix m2 = new Matrix();
    m2.postRotate(startAngel, c1.center.x, c1.center.y);
    resultPath.transform(m2);
    return resultPath;
}
 

protected void drawText(float radius, float size, GeoPoint pt, GISDisplay display) {
        if (TextUtils.isEmpty(mText))
            return;

        Paint textPaint = new Paint();
        textPaint.setColor(mTextColor);
        textPaint.setAntiAlias(true);
        textPaint.setStyle(Paint.Style.FILL);
        textPaint.setStrokeCap(Paint.Cap.ROUND);

        float gap = (float) (1 / display.getScale());
        float innerRadius = radius - gap;
        float textSize = size * innerRadius; // initial text size

        Rect textRect = new Rect();
        textPaint.setTextSize(size);
        textPaint.getTextBounds(mText, 0, mText.length(), textRect);
        textPaint.setTextSize(textSize);

        float halfW = textRect.width() * innerRadius / 2;
        float halfH = textRect.height() * innerRadius / 2;
//        float outerTextRadius = (float) Math.sqrt(halfH * halfH + halfW * halfW);
//        float textScale = innerRadius / outerTextRadius;

        float textX = (float) (pt.getX() - halfW - radius / 2);
        float textY = (float) (pt.getY() + halfH - radius / 2);

        switch (mTextAlignment) {
            case ALIGN_TOP:
                textY = textY - halfH * 2;
                break;
            case ALIGN_TOP_RIGHT:
                textX = textX + halfW * 2 - halfW * .5f;
                textY = textY - halfH * 2;
                break;
            case ALIGN_RIGHT:
                textX = textX + halfW * 2 - halfW * 0.25f;
                break;
            case ALIGN_BOTTOM_RIGHT:
                textX = textX + halfW * 2 - halfW * .5f;
                textY = textY + halfH * 2;
                break;
            case ALIGN_BOTTOM:
                textY = textY + halfH * 2;
                break;
            case ALIGN_BOTTOM_LEFT:
                textX = textX - halfW * 2 + halfW * .5f;
                textY = textY + halfH * 2;
                break;
            case ALIGN_LEFT:
                textX = textX - halfW * 2 + halfW * 0.25f;
                break;
            case ALIGN_TOP_LEFT:
                textX = textX - halfW * 2 + halfW * .5f;
                textY = textY - halfH * 2;
                break;
        }
        Path textPath = new Path();
        textPaint.getTextPath(mText, 0, mText.length(), textX, textY, textPath);
        textPath.close();

        Matrix matrix = new Matrix();
        matrix.reset();
        matrix.setScale(1, -1, (float) pt.getX(), (float) pt.getY());
        textPath.transform(matrix);

        display.drawPath(textPath, textPaint);
    }
 

public Path getActualElementPath() {
    Path path = new Path(elementPath);
    path.transform(displayMatrix);
    return path;
}