Zeichnung auf Leinwand - PorterDuff.- Modus.KLAR zieht schwarz! Warum?

Verwenden Sie diese Anweisung, während der Initialisierung des view

setLayerType(LAYER_TYPE_HARDWARE, null);

InformationsquelleAutor der Antwort Mukesh Kumar

lösen unerwünschte PorterDuff Effekt

verwenden Sie die einfachste Methode auf den ersten, wie der OP das problem, eine Path.arcTo(*, *, *, *, false) ist genug -- Hinweis: es ist arcTo, nicht addArc, und die false bedeutet no forceMoveTo vor der Zugabe arc -- es gibt keine Notwendigkeit für PorterDuff.

Path arcPath = new Path();
@Override
protected void onDraw(Canvas canvas) {
    arcPath.rewind();
    arcPath.moveTo(arcRectF.centerX, arcRectF.centerY);
    arcPath.arcTo(arcRectF, -90, currentAngleSweep, false);
    arcPath.close();
    canvas.clipPath(arcPath, Region.Op.DIFFERENCE);
    canvas.drawBitmap(bitmap, circleSourceRect, circleDestRect, arcPaint);
}

wenn Sie wirklich brauchen, PorterDuff, vor allem für komplexe Farb-morphing, wie Farbverläufe, blending, nicht zeichnen, Farbe oder Form oder bitmap mit PorterDuff Filterwirkung direkt an das Standard-canvas in onDraw(Canvas)verwenden einige Pufferung/Ziel-bitmap[s] mit alpha Kanal--und setHasAlpha(true)-- zum speichern des Ergebnisses aus PorterDuff filtern, endlich zeichnen Sie die bitmap, um die Standard-Leinwand, ohne die Anwendung von filtern außer matrix ändern.

hier ein lauffähiges Beispiel zu erstellen, Grenze verwischt-Runde Bild:

import android.annotation.SuppressLint;
import android.content.Context;
import android.graphics.Bitmap;
import android.graphics.Canvas;
import android.graphics.Color;
import android.graphics.Matrix;
import android.graphics.Paint;
import android.graphics.Path;
import android.graphics.PorterDuff;
import android.graphics.PorterDuffXfermode;
import android.graphics.RadialGradient;
import android.graphics.Rect;
import android.graphics.RectF;
import android.graphics.Shader;
import android.support.annotation.Nullable;
import android.util.AttributeSet;
import android.widget.ImageView;

/**
* Created by zdave on 6/22/17.
*/

public class BlurredCircleImageViewShader extends ImageView {
private Canvas mCanvas;
private Paint mPaint;
private Matrix matrix;
private static final float GRADIENT_RADIUS = 600f;  //any value you like, but should be big enough for better resolution.
private Shader gradientShader;
private Bitmap bitmapGradient;
private Bitmap bitmapDest;
private Canvas canvasDest;
public BlurredCircleImageViewShader(Context context) {
    this(context, null);
}

public BlurredCircleImageViewShader(Context context, @Nullable AttributeSet attrs) {
    this(context, attrs, 0);
}

public BlurredCircleImageViewShader(Context context, @Nullable AttributeSet attrs, int defStyleAttr) {
    super(context, attrs, defStyleAttr);
    mPaint = new Paint(Paint.ANTI_ALIAS_FLAG);
    matrix = new Matrix();
    int[] colors = new int[]{Color.BLACK, Color.BLACK, Color.TRANSPARENT};
    float[] colorStops = new float[]{0f, 0.5f, 1f};
    gradientShader = new RadialGradient(GRADIENT_RADIUS, GRADIENT_RADIUS, GRADIENT_RADIUS, colors, colorStops, Shader.TileMode.CLAMP);
    mPaint.setShader(gradientShader);

    bitmapGradient = Bitmap.createBitmap((int)(GRADIENT_RADIUS * 2), (int)(GRADIENT_RADIUS * 2), Bitmap.Config.ARGB_8888);
    bitmapDest = bitmapGradient.copy(Bitmap.Config.ARGB_8888, true);

    Canvas canvas = new Canvas(bitmapGradient);
    canvas.drawRect(0, 0, GRADIENT_RADIUS * 2, GRADIENT_RADIUS * 2, mPaint);

    canvasDest = new Canvas(bitmapDest);
}

@Override
protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
    super.onMeasure(widthMeasureSpec, heightMeasureSpec);
    int width = getMeasuredWidth();
    setMeasuredDimension(width, width);
}

@Override
protected void onDraw(Canvas canvas){
    /*uncomment each of them to show the effect, the first and the third one worked, the second show the same problem as OP's*/
    //drawWithLayers(canvas);  //unrecommended.
    //drawWithBitmap(canvas);  //this shows transparent as black
    drawWithBitmapS(canvas);   //recommended.
}
@SuppressLint("WrongCall")
private void drawWithLayers(Canvas canvas){
    mPaint.setXfermode(new PorterDuffXfermode(PorterDuff.Mode.DST_IN));
    float width = canvas.getWidth();
    float hWidth = width / 2;
    //both saveLayerAlpha saveLayer worked here, and if without either of them,
    //the transparent area will be black.
    //int count = canvas.saveLayerAlpha(0, 0, getWidth(), getHeight(), 255, Canvas.ALL_SAVE_FLAG);
    int count = canvas.saveLayer(0, 0, getWidth(), getHeight(), null, Canvas.ALL_SAVE_FLAG);
    super.onDraw(canvas);
    float scale = hWidth/GRADIENT_RADIUS;
    matrix.setTranslate(hWidth - GRADIENT_RADIUS, hWidth - GRADIENT_RADIUS);
    matrix.postScale(scale, scale, hWidth, hWidth);
    gradientShader.setLocalMatrix(matrix);

    canvas.drawRect(0, 0, width, width, mPaint);

    canvas.restoreToCount(count);
}
@SuppressLint("WrongCall")
private void drawWithBitmap(Canvas canvas){
    super.onDraw(canvas);
    float scale = canvas.getWidth() / (GRADIENT_RADIUS * 2);
    matrix.setScale(scale, scale);
    mPaint.setXfermode(new PorterDuffXfermode(PorterDuff.Mode.DST_IN));
    canvas.drawBitmap(bitmapGradient, matrix, mPaint);  //transparent area is still black.
}
@SuppressLint("WrongCall")
private void drawWithBitmapS(Canvas canvas){
    float scale = canvas.getWidth() / (GRADIENT_RADIUS * 2);
    int count = canvasDest.save();
    canvasDest.scale(1/scale, 1/scale); //tell super to draw in 1/scale.
    super.onDraw(canvasDest);
    canvasDest.restoreToCount(count);

    mPaint.setXfermode(new PorterDuffXfermode(PorterDuff.Mode.DST_IN));
    canvasDest.drawBitmap(bitmapGradient, 0, 0, mPaint);

    matrix.setScale(scale, scale);  //to scale bitmapDest to canvas.
    canvas.drawBitmap(bitmapDest, matrix, null);
    }
 }

einige Hinweise:
1, dieser Blick reicht ImageView nicht View gibt es einige Unterschiede.

2, warum drawWithLayers --saveLayer oder saveLayerAlpha-- ist unrecommended: Sie sind unsicher, manchmal nicht richtig funktioniert(Karte transparent schwarz), insbesondere für View deren onDraw(Canvas) leer ist, während ImageView.onDraw(Canvas) verwendet eine Drawable ziehen einige; b, Sie sind teuer, Sie reservieren off-screen bitmap zum speichern von temporären Zeichnung ergeben, und es gibt keine klaren Hinweise auf eine beliebige Ressource recycling-Mechanismus.

3, verwenden Sie Ihre eigenen bitmap - [s], ist besser für die angepasste Ressourcen-recycling.

Einige Leute sagten, es ist unmöglich, verwendet PorterDuff ohne allocation bitmap[s] jede Zeichnung, da die bitmap Breite, Höhe kann nicht bestimmt werden, vor Zeichnung/layout/Messen.

Sie KÖNNEN die Pufferung verwenden bitmap[s] für PorterDuff Zeichnung:

auf den ersten, reservieren Sie etwas groß genug, bitmap[s].

zeichnen Sie dann auf die bitmap[s] mit einigen matrix.

und die, zeichnen der bitmap[s] in eine Ziel-bitmap mit einigen matrix.

endlich ziehen die Ziel-bitmap in Leinwand, mit einigen matrix.

einige Leute empfehlen, setLayerType ("Ansicht".LAYER_TYPE_SOFTWARE, null), das ist keine option für mich, da es wird Ursache onDraw(Canvas) werden in einer Schleife aufgerufen.

Ergebnis Bild
Quelle Bild

InformationsquelleAutor der Antwort zdave

speichern Sie einfach die Leinwand und wiederherstellen nach

canvas.saveLayer(clipContainer, null, Canvas.ALL_SAVE_FLAG);
canvas.drawRoundRect(rectTopGrey, roundCorners, roundCorners, greyPaint);
canvas.drawRoundRect(rectTopGreyClip, roundCorners, roundCorners, clipPaint);
canvas.restore();

in diesem Fall erste Rechteck wird als Ziel für https://developer.android.com/reference/android/graphics/PorterDuff.Mode und das zweite Rechteck als Quelle

InformationsquelleAutor der Antwort Mykola Tychyna