Android Masque bitmap sur toile gen espace noir

J'ai un masque bitmap avec la moitié est de couleur rouge et est transparent comme ceci
https://www.dropbox.com/s/931ixef6myzusi0/s_2.png

Je veux utiliser un masque bitmap pour extraire du contenu sur la toile visible uniquement dans la zone rouge, un code comme ceci:

Paint paint = new Paint();


public void draw(Canvas canvas) {
//draw content here
  ...

//and mask bitmap here
  paint.setXfermode(new PorterDuffXfermode(android.graphics.PorterDuff.Mode.DST_IN));
  canvas.drawBitmap(maskBitmap, 0, 0, paint);

}

Le résultat que mon attend (contenu visible uniquement dans la zone rouge, MAIS LA ZONE TRANSPARENTE DEVENIR le NOIR EST le PROBLÈME!!!!)

cette image résultat :https://www.dropbox.com/s/mqj48992wllfkiq/s_2%20copy.png
Quelqu'un m'aider???

OriginalL'auteur user3693347 | 2014-05-31

Voici une solution qui m'a aidé à mettre en œuvre de masquage:

public void draw(Canvas canvas) {
        Bitmap original = BitmapFactory.decodeResource(getContext().getResources(),R.drawable.original_image);
        Bitmap mask = BitmapFactory.decodeResource(getContext().getResources(),R.drawable.mask_image);

        //You can change original image here and draw anything you want to be masked on it.

        Bitmap result = Bitmap.createBitmap(mask.getWidth(), mask.getHeight(), Config.ARGB_8888);
        Canvas tempCanvas = new Canvas(result);
        Paint paint = new Paint(Paint.ANTI_ALIAS_FLAG);
        paint.setXfermode(new PorterDuffXfermode(Mode.DST_IN));
        tempCanvas.drawBitmap(original, 0, 0, null);
        tempCanvas.drawBitmap(mask, 0, 0, paint);
        paint.setXfermode(null);

        //Draw result after performing masking
        canvas.drawBitmap(result, 0, 0, new Paint());
}

Le masque doit être une image blanche avec de la transparence.

Il fonctionne comme ceci:

Android Masque bitmap sur toile gen espace noir

ce sera assez lent, car l'écran hors tension de la toile n'est pas l'accélération matérielle
Je trouve que la toile graphismes sont encore tout à fait nécessaire, même si vous utiliser OpenGL, car elle peut générer des graphiques à la volée qui peut ensuite être chargé un OpenGL shader. Cela dit, c'est toujours utile.
mais la création d'image bitmap dans onDraw() peut causer de la mémoire Exception
Il ne doit pas être blanc, comme vous l'avez mentionné. Transparent canal suffit. Vérifier developer.android.com/reference/android/graphics/...
Ce que vous passé en paramètre de tirage

OriginalL'auteur Sergey Pekar

6

J'ai rencontré le même problème dans mon affichage personnalisé et au lieu de décodage de l'image à partir d'une ressource, j'avais créé l'image d'origine et le masquage d'image à partir du zéro via canvas.draw*() méthodes (car à la fois l'origine et le masque sont des formes de base). J'ai fait le blank opaque space au lieu d'un transparent. Je l'ai fixée par la définition d'une couche matérielle de mon point de vue.
```
View.setLayerType(LAYER_TYPE_HARDWARE, paint);
```
Plus d'info sur le pourquoi de ce qui est à faire ici: https://stackoverflow.com/a/33483016/4747587

OriginalL'auteur Henry

Bitmap finalMasking = stackMaskingProcess(imageBitmap, bitmapMasking);


private Bitmap stackMaskingProcess(Bitmap _originalBitmap, Bitmap _maskingBitmap) {
        try {
            if (_originalBitmap != null)
            {
                int intWidth = _originalBitmap.getWidth();
                int intHeight = _originalBitmap.getHeight();
                resultMaskBitmap = Bitmap.createBitmap(intWidth, intHeight, Bitmap.Config.ARGB_8888);
                getMaskBitmap = Bitmap.createScaledBitmap(_maskingBitmap, intWidth, intHeight, true);
                Canvas mCanvas = new Canvas(resultMaskBitmap);
                Paint paint = new Paint(Paint.ANTI_ALIAS_FLAG);
                paint.setXfermode(new PorterDuffXfermode(PorterDuff.Mode.DST_IN));
                mCanvas.drawBitmap(_originalBitmap, 0, 0, null);
                mCanvas.drawBitmap(getMaskBitmap, 0, 0, paint);
                paint.setXfermode(null);
                paint.setStyle(Paint.Style.STROKE);
            }
        } catch (OutOfMemoryError o) {
            o.printStackTrace();
        }
        return resultMaskBitmap;
    }

OriginalL'auteur Er. Praful Parmar

J'aime l'approche de Er. Praful Parmar de l' réponse, mais pour moi, il n'a pas tout à fait comme prévu. J'ai eu des problèmes, parce que certains de mise à l'échelle se passait sans intention.

Mon Bitmaps a une densité différente de celle de mon appareil et c'gâché les choses.

Aussi je voulais réduire la création d'Objets, donc j'ai déplacé le Paint objet d'une constante pour la réutilisation.

Voici donc mon utils méthode:

  public static final//
  Bitmap createWithMask(final Bitmap img, final Bitmap mask) {
    final Bitmap result = Bitmap.createBitmap(img.getWidth(), img.getHeight(),
        Bitmap.Config.ARGB_8888);
    result.setDensity(originalBitmap.getDensity()); //to avoid scaling if density of 'img' is different form the default on your device
    final Canvas canvas = new Canvas(result);
    canvas.drawBitmap(img, 0, 0, null);
    canvas.drawBitmap(mask, 0, 0, PAINT_FOR_MASK);
    return result;
  }//end-method

  private static final Paint PAINT_FOR_MASK = createPaintForMask();

  private static final//
  Paint createPaintForMask() {
    final Paint paint = new Paint();
    paint.setXfermode(new PorterDuffXfermode(PorterDuff.Mode.DST_IN));
    return paint;
  }//end-method

OriginalL'auteur MrSmith42

Vous devez vous connecter pour publier un commentaire.