Comment mettre en œuvre l'effaceur d'image tactile lisse dans Android?

Question

J'ai déjà vu fingurePaint.java à partir de démos API. Je veux mettre en place un effaceur tactile lisse pour effacer des parties de l'image en appuyant sur le bouton dans Android.

fingurePaint m'a dit de mettre en œuvre cette

mPaint.setXfermode(new PorterDuffXfermode(PorterDuff.Mode.CLEAR)); 

Mais cela ne fonctionne pas pour effacer l'image. Il travaille à effacer quelque chose qui est dessiné par le toucher.

public class SandboxView extends View implements OnTouchListener { 
    public final Bitmap bitmap; 
    private final int width; 
    private final int height; 
    private Matrix transform = new Matrix(); 

    private Vector2D position = new Vector2D(); 
    private float scale = 1; 
    private float angle = 0; 
    public boolean isInitialized = false; 
    private TouchManager touchManager = new TouchManager(2); 
    final GestureDetector mGesDetect; 


    // Debug helpers to draw lines between the two touch points 
    private Vector2D vca = null; 
    private Vector2D vcb = null; 
    private Vector2D vpa = null; 
    private Vector2D vpb = null; 

    private float mX, mY; 
    private static final float TOUCH_TOLERANCE = 4; 
    private Path mPath; 
    private Canvas mCanvas; 
    private Paint  mPaint; 
    private Paint mBitmapPaint; 
    public SandboxView(Context context, Bitmap bitmap) { 
     super(context); 

     this.bitmap = bitmap; 
     this.width = bitmap.getWidth(); 
     this.height = bitmap.getHeight(); 
     this.mGesDetect = new GestureDetector(context, new DoubleTapGestureDetector()); 

     setOnTouchListener(this); 
    } 


    private float getDegreesFromRadians(float angle) { 
     return (float)(angle * 360.0/Math.PI); 
    } 

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

     if (!isInitialized) { 
      Bitmap mBitmap = bitmap.createBitmap(320, 480, Bitmap.Config.ARGB_8888); 
      mCanvas = new Canvas(mBitmap); 
      mPaint = new Paint(); 
      mPath = new Path(); 
      mPaint.setAntiAlias(true); 
      mPaint.setDither(true); 
      mPaint.setColor(0xFFFF0000); 
      mPaint.setStyle(Paint.Style.STROKE); 
      mPaint.setStrokeJoin(Paint.Join.ROUND); 
      mPaint.setStrokeCap(Paint.Cap.ROUND); 
      mPaint.setStrokeWidth(12); 
      mPaint.setAlpha(0); 
      mPaint.setXfermode(new PorterDuffXfermode(PorterDuff.Mode.CLEAR)); 
      mPaint.setAntiAlias(true); 

      mBitmapPaint = new Paint(Paint.DITHER_FLAG); 


      int w = getWidth(); 
      int h = getHeight(); 
      position.set(w/2, h/2); 
      isInitialized = true; 
     } 
     if(isEraser==1){ 
      canvas.drawColor(80000000); 


      canvas.drawBitmap(bitmap, transform, mBitmapPaint); 

      canvas.drawPath(mPath, mPaint); 
     } 
     else{ 


     Paint paint = new Paint(); 

     transform.reset(); 
     transform.postTranslate(-width/2.0f, -height/2.0f); 
     transform.postRotate(getDegreesFromRadians(angle)); 
     transform.postScale(scale, scale); 
     transform.postTranslate(position.getX(), position.getY()); 

     canvas.drawBitmap(bitmap, transform, paint); 

     try { 
      /*paint.setColor(0xFF007F00); 
      canvas.drawCircle(vca.getX(), vca.getY(), 64, paint); 
      paint.setColor(0xFF7F0000); 
      canvas.drawCircle(vcb.getX(), vcb.getY(), 64, paint); 

      paint.setColor(0xFFFF0000); 
      canvas.drawLine(vpa.getX(), vpa.getY(), vpb.getX(), vpb.getY(), paint); 
      paint.setColor(0xFF00FF00); 
      canvas.drawLine(vca.getX(), vca.getY(), vcb.getX(), vcb.getY(), paint);*/ 




     } 
     catch(NullPointerException e) { 
      // Just being lazy here... 
     } 
     } 
    } 

    private void touch_start(float x, float y) { 
     mPath.reset(); 
     mPath.moveTo(x, y); 
     mX = x; 
     mY = y; 
    } 
    private void touch_move(float x, float y) { 
     float dx = Math.abs(x - mX); 
     float dy = Math.abs(y - mY); 
     if (dx >= TOUCH_TOLERANCE || dy >= TOUCH_TOLERANCE) { 
      mPath.quadTo(mX, mY, (x + mX)/2, (y + mY)/2); 
      mX = x; 
      mY = y; 
     } 
    } 
    private void touch_up() { 
     mPath.lineTo(mX, mY); 
     mCanvas.drawPath(mPath, mPaint); 
     mPath.reset(); 
    } 




    @Override 
    public boolean onTouch(View v, MotionEvent event) { 

     if(isEraser ==1){ 
      float x = event.getX(); 
      float y = event.getY(); 

      mPaint.setXfermode(new PorterDuffXfermode(PorterDuff.Mode.CLEAR)); 


      switch (event.getAction()) { 
       case MotionEvent.ACTION_DOWN: 
        touch_start(x, y); 
        invalidate(); 
        break; 
       case MotionEvent.ACTION_MOVE: 
        touch_move(x, y); 
        invalidate(); 
        break; 
       case MotionEvent.ACTION_UP: 
        touch_up(); 
        invalidate(); 
        break; 
      } 
      return true; 
     } 
     else{ 
     vca = null; 
     vcb = null; 
     vpa = null; 
     vpb = null; 
     mGesDetect.onTouchEvent(event); 

     try { 
      touchManager.update(event); 

      if (touchManager.getPressCount() == 1) { 
       vca = touchManager.getPoint(0); 
       vpa = touchManager.getPreviousPoint(0); 
       position.add(touchManager.moveDelta(0)); 
      } 
      else { 
       if (touchManager.getPressCount() == 2) { 
        vca = touchManager.getPoint(0); 
        vpa = touchManager.getPreviousPoint(0); 
        vcb = touchManager.getPoint(1); 
        vpb = touchManager.getPreviousPoint(1); 

        Vector2D current = touchManager.getVector(0, 1); 
        Vector2D previous = touchManager.getPreviousVector(0, 1); 
        float currentDistance = current.getLength(); 
        float previousDistance = previous.getLength(); 

        if (previousDistance != 0) { 
         scale *= currentDistance/previousDistance; 
        } 

        angle -= Vector2D.getSignedAngleBetween(current, previous); 
       } 
      } 

      invalidate(); 
     } 
     catch(Throwable t) { 
      // So lazy... 
     } 
     return true; 
     } 
    } 
    class DoubleTapGestureDetector extends GestureDetector.SimpleOnGestureListener { 


     @Override 
     public boolean onDoubleTap(MotionEvent e) { 
      colorseekbar.setVisibility(View.INVISIBLE); 
      opacityseekbar.setVisibility(View.INVISIBLE); 
      return true; 
     } 
    } 

}

Alors s'il vous plaît aidez-moi à effacer les parties de l'image en utilisant mouvement tactile.

Merci d'avance.

Answer 1

Première Déclarer votre peinture avec toutes les propriétés de votre constructeur.

écrire ce code dans votre onDraw() méthode

@Override 
protected void onDraw(Canvas canvas) 
    { 
    System.out.println("come in on draw......"); 
    canvas.drawColor(Color.TRANSPARENT); 
    canvas.drawBitmap(mBitmap, 0, 0, mPaint); 
      if(eraser==true) 
       mPaint.setColor(Color.TRANSPARENT): 
      else 
       mPaint.setColor(Color.RED): 
    canvas.drawPath(mPath, mPaint); 

    super.dispatchDraw(canvas); 
} 

seconde solution:

appel ci-dessous dans votre méthode TOUCH_MOVE() méthode

mBitmap.setPixel (x, y, Color.TRANSPARENT); Cette méthode va changer votre bitmap, vous devez passer seulement X, Y & COULEUR

public void changeBitmap(int x, int y, Bitmap mBitmap) 
{ 
Bitmap tempBitmap = Bitmap.createBitmap(mBitmap); //Edited code 
tempBitmap.setPixel(x, y, Color.TRANSPARENT); 
} 



private void touch_move(float x, float y) { 
     float dx = Math.abs(x - mX); 
     float dy = Math.abs(y - mY); 
     if (dx >= TOUCH_TOLERANCE || dy >= TOUCH_TOLERANCE) { 
      mPath.quadTo(mX, mY, (x + mX)/2, (y + mY)/2); 
      mX = x; 
      mY = y; 
      changeBitmap(x, y, your_bitmap) 
     } 
    } 

Answer 2

N'est-il pas préférable d'inverser ce cas? Peignez simplement sur votre image avec la couleur d'arrière-plan et après tout lors de l'enregistrement, fusionnez ces couches si nécessaire.

Answer 3

Définir une toile temporaire et bitmap puis tracez votre chemin ou d'une ligne, cercle, quoi que ce soit d'image sur les événements tactiles et transmettre cette bitmap temporaire à canvas dans onDraw votre travail sera fait correctement, et aussi si vous voulez faire effacement puis effectuez votre effacement sur ce canevas temporaire.

protected void onSizeChanged(int w, int h, int oldw, int oldh) { 
     super.onSizeChanged(w, h, oldw, oldh); 
     TemporaryBitmap = Bitmap.createBitmap(w, h, Bitmap.Config.ARGB_4444); 
     TemporaryCanvas = new Canvas(TemporaryBitmap); 
} 
TemporaryCanvas.drawColor(0, PorterDuff.Mode.clear); 
public void onDraw(Canvas canv){ 
canv.drawBitmap(TemporaryBitmap, matrix, paint);