Android, canevas: Comment effacer (supprimer le contenu de) un canevas (= bitmaps), vivant dans une surfaceView?

Afin de créer un jeu simple, j'ai utilisé un modèle qui dessine un canevas avec des bitmaps comme celui-ci:

private void doDraw(Canvas canvas) {
    for (int i=0;i<8;i++)
        for (int j=0;j<9;j++)
            for (int k=0;k<7;k++)   {
    canvas.drawBitmap(mBits[allBits[i][j][k]], i*50 -k*7, j*50 -k*7, null); } }

(Le canevas est défini dans "run ()" / le SurfaceView vit dans un GameThread.)

Ma première question est de savoir comment effacer (ou redessiner) l' ensemble du canevas pour une nouvelle mise en page?
Deuxièmement, comment puis-je mettre à jour une partie seulement de l'écran?

// This is the routine that calls "doDraw":
public void run() {
    while (mRun) {
        Canvas c = null;
        try {
            c = mSurfaceHolder.lockCanvas(null);
            synchronized (mSurfaceHolder) {
                if (mMode == STATE_RUNNING) 
                    updateGame();
                doDraw(c);          }
        } finally {
            if (c != null) {
                mSurfaceHolder.unlockCanvasAndPost(c);  }   }   }       }

Comment effacer (ou redessiner) le canevas ENTIER pour une nouvelle mise en page (= essayer le jeu)?

Appelez simplement Canvas.drawColor(Color.BLACK), ou quelle que soit la couleur que vous souhaitez utiliser Canvas.

Et: comment puis-je mettre à jour juste une partie de l'écran?

Il n’existe pas de méthode qui consiste simplement à mettre à jour une «partie de l’écran» car Android OS redessine chaque pixel lors de la mise à jour de l’écran. Mais, lorsque vous n'effacez pas d'anciens dessins sur votre Canvas, les anciens dessins sont toujours à la surface et c'est probablement une façon de "mettre à jour juste une partie" de l'écran.

Donc, si vous voulez "mettre à jour une partie de l'écran", évitez simplement d'appeler Canvas.drawColor()method.

Dessiner une couleur transparente avec le mode clair PorterDuff fait l'affaire pour ce que je voulais.

Canvas.drawColor(Color.TRANSPARENT, PorterDuff.Mode.CLEAR)

J'ai trouvé ceci dans des groupes Google et cela a fonctionné pour moi.

Paint clearPaint = new Paint();
clearPaint.setXfermode(new PorterDuffXfermode(PorterDuff.Mode.CLEAR));
canvas.drawRect(0, 0, width, height, clearPaint); 

Cela supprime les rectangles de dessins, etc. tout en conservant le bitmap défini.

J'ai essayé la réponse de @mobistry:

canvas.drawColor(Color.TRANSPARENT, Mode.CLEAR);

Mais cela n'a pas fonctionné pour moi.

La solution, pour moi, était:

canvas.drawColor(Color.TRANSPARENT, Mode.MULTIPLY);

Peut-être que quelqu'un a le même problème.

utilisez la méthode de réinitialisation de la classe Path

Path.reset();

mBitmap.eraseColor(Color.TRANSPARENT);

canvas.drawBitmap(mBitmap, 0, 0, mBitmapPaint);

veuillez coller ci-dessous le code sur le constructeur de classe d'extension de surfaceview .............

codage constructeur

    SurfaceHolder holder = getHolder();
    holder.addCallback(this);

    SurfaceView sur = (SurfaceView)findViewById(R.id.surfaceview);
    sur.setZOrderOnTop(true);    // necessary
    holder = sur.getHolder();
    holder.setFormat(PixelFormat.TRANSPARENT);

codage xml

    <com.welcome.panelview.PanelViewWelcomeScreen
        android:id="@+id/one"
        android:layout_width="600px"
        android:layout_height="312px"
        android:layout_gravity="center"
        android:layout_marginTop="10px"
        android:background="@drawable/welcome" />

essayez le code ci-dessus ...

Voici le code d'un exemple minimal montrant que vous devez toujours redessiner chaque pixel du canevas à chaque image.

Cette activité dessine un nouveau Bitmap toutes les secondes sur SurfaceView, sans effacer l'écran auparavant. Si vous le testez, vous verrez que le bitmap n'est pas toujours écrit dans le même tampon, et l'écran alternera entre les deux tampons.

Je l'ai testé sur mon téléphone (Nexus S, Android 2.3.3) et sur l'émulateur (Android 2.2).

public class TestCanvas extends Activity {
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(new TestView(this));
    }
}

class TestView extends SurfaceView implements SurfaceHolder.Callback {

    private TestThread mThread;
    private int mWidth;
    private int mHeight;
    private Bitmap mBitmap;
    private SurfaceHolder mSurfaceHolder;

    public TestView(Context context) {
        super(context);
        mThread = new TestThread();
        mBitmap = BitmapFactory.decodeResource(context.getResources(), R.drawable.icon);
        mSurfaceHolder = getHolder();
        mSurfaceHolder.addCallback(this);
    }

    @Override
    public void surfaceChanged(SurfaceHolder holder, int format, int width,
            int height) {
        mWidth = width;
        mHeight = height;
        mThread.start();
    }

    @Override
    public void surfaceCreated(SurfaceHolder holder) {/* Do nothing */}

    @Override
    public void surfaceDestroyed(SurfaceHolder holder) {
        if (mThread != null && mThread.isAlive())
            mThread.interrupt();
    }

    class TestThread extends Thread {
        @Override
        public void run() {
            while (!isInterrupted()) {
                Canvas c = null;
                try {
                    c = mSurfaceHolder.lockCanvas(null);
                    synchronized (mSurfaceHolder) {
                        c.drawBitmap(mBitmap, (int) (Math.random() * mWidth), (int) (Math.random() * mHeight), null);
                    }
                } finally {
                    if (c != null)
                        mSurfaceHolder.unlockCanvasAndPost(c);
                }

                try {
                    sleep(1000);
                } catch (InterruptedException e) {
                    interrupt();
                }
            }
        }   
    }
}

Pour moi, appeler Canvas.drawColor(Color.TRANSPARENT, PorterDuff.Mode.CLEAR)ou quelque chose de similaire ne fonctionnerait qu'après avoir touché l'écran. Donc, j'appellerais la ligne de code ci-dessus, mais l'écran ne s'effacerait qu'après avoir touché l'écran. Donc ce qui a fonctionné pour moi était d'appeler invalidate()suivi de init()qui est appelé au moment de la création pour initialiser la vue.

private void init() {
    setFocusable(true);
    setFocusableInTouchMode(true);
    setOnTouchListener(this);

    mPaint = new Paint();
    mPaint.setAntiAlias(true);
    mPaint.setDither(true);
    mPaint.setColor(Color.BLACK);
    mPaint.setStyle(Paint.Style.STROKE);
    mPaint.setStrokeJoin(Paint.Join.ROUND);
    mPaint.setStrokeCap(Paint.Cap.ROUND);
    mPaint.setStrokeWidth(6);

    mCanvas = new Canvas();
    mPaths = new LinkedList<>();

    addNewPath();
}

canvas.drawColor(Color.TRANSPARENT, Mode.MULTIPLY);

Effacer sur Canvas dans java android est similaire à l'effacement de HTML Canvas via javascript avec globalCompositeOperation. La logique était similaire.

U choisira la logique DST_OUT (Destination Out).

paint.setXfermode(new PorterDuffXfermode(PorterDuff.Mode.DST_OUT));

Remarque: DST_OUT est plus utile car il peut effacer 50% si la couleur de la peinture a 50% alpha. Donc, pour être complètement transparent, l'alpha de la couleur doit être de 100%. Il est recommandé d'appliquer paint.setColor (Color.WHITE). Et assurez-vous que le format de l'image du canevas était RGBA_8888.

Une fois effacé, revenez au dessin normal avec SRC_OVER (Source Over).

paint.setXfermode(new PorterDuffXfermode(PorterDuff.Mode.SRC_OVER));

La mise à jour de l'affichage de petite zone devra littéralement accéder au matériel graphique, et peut-être n'est-elle pas prise en charge.

Le plus proche pour des performances optimales est l'utilisation de plusieurs couches d'images.

N'oubliez pas d'appeler invalidate ();

canvas.drawColor(backgroundColor);
invalidate();
path.reset();

Essayez de supprimer la vue à onPause () d'une activité et ajoutez onRestart ()

LayoutYouAddedYourView.addView (YourCustomView); LayoutYouAddedYourView.removeView (YourCustomView);

Au moment où vous ajoutez votre vue, la méthode onDraw () est appelée.

YourCustomView, est une classe qui étend la classe View.

Dans mon cas, je dessine ma toile en linéaire. Pour nettoyer et redessiner:

    LinearLayout linearLayout = findViewById(R.id.myCanvas);
    linearLayout.removeAllViews();

puis, j'appelle la classe avec les nouvelles valeurs:

    Lienzo fondo = new Lienzo(this,items);
    linearLayout.addView(fondo);

C'est la classe Lienzo:

class Lienzo extends View {
    Paint paint;
    RectF contenedor;
    Path path;
    ArrayList<Items>elementos;

    public Lienzo(Context context,ArrayList<Items> elementos) {
        super(context);
        this.elementos=elementos;
        init();
    }

    private void init() {
        path=new Path();
        paint = new Paint();
        contenedor = new RectF();
        paint.setStyle(Paint.Style.FILL);
    }


    @Override
    protected void onDraw(Canvas canvas) {
        super.onDraw(canvas);

        contenedor.left = oneValue;
        contenedor.top = anotherValue;
        contenedor.right = anotherValue;
        contenedor.bottom = anotherValue;

        float angulo = -90; //starts drawing at 12 o'clock
        //total= sum of all element values
        for (int i=0;i<elementos.size();i++){
            if (elementos.get(i).angulo!=0 && elementos.get(i).visible){
                paint.setColor(elementos.get(i).backColor);
                canvas.drawArc(contenedor,angulo,(float)(elementos.get(i).value*360)/total,true,paint);

                angulo+=(float)(elementos.get(i).value*360)/total;
            }
        } //for example
    }
}

Avec l'approche suivante, vous pouvez effacer toute la toile ou juste une partie de celle-ci.
N'oubliez pas de désactiver l'accélération matérielle car PorterDuff.Mode.CLEAR ne fonctionne pas avec l'accélération matérielle et enfin appeler setWillNotDraw(false)car nous surchargons la onDrawméthode.

//view's constructor
setWillNotDraw(false);
setLayerType(LAYER_TYPE_SOFTWARE, null);

//view's onDraw
Paint TransparentPaint = new Paint();
TransparentPaint.setXfermode(new PorterDuffXfermode(PorterDuff.Mode.CLEAR));
canvas.drawRect(0, 0, width, height, TransparentPaint); 

Votre première exigence, comment effacer ou redessiner la toile entière - Réponse - utilisez la méthode canvas.drawColor (color.Black) pour effacer l'écran avec une couleur de noir ou tout ce que vous spécifiez.

Votre deuxième exigence, comment mettre à jour une partie de l'écran - Réponse - par exemple si vous voulez garder toutes les autres choses inchangées à l'écran mais dans une petite zone de l'écran pour afficher un entier (par exemple un compteur) qui augmente toutes les cinq secondes. puis utilisez la méthode canvas.drawrect pour dessiner cette petite zone en spécifiant gauche en haut à droite en bas et peignez. puis calculez la valeur de votre compteur (en utilisant postdalayed pendant 5 secondes etc., llike Handler.postDelayed (Runnable_Object, 5000);), convertissez-la en chaîne de texte, calculez les coordonnées x et y dans ce petit rect et utilisez la vue texte pour afficher le changement valeur de compteur.

J'ai dû utiliser une passe de dessin distincte pour effacer la toile (verrouiller, dessiner et déverrouiller):

Canvas canvas = null;
try {
    canvas = holder.lockCanvas();
    if (canvas == null) {
        // exit drawing thread
        break;
    }
    canvas.drawColor(colorToClearFromCanvas, PorterDuff.Mode.CLEAR);
} finally {
    if (canvas != null) {
        holder.unlockCanvasAndPost(canvas);
    }
}

Il suffit d'appeler

canvas.drawColor (Couleur.TRANSPARENT)