how to remove background from any image in android

Question

I want to remove the background of photo .but not able to find anything relevant actually I want this type of application https://play.google.com/store/apps/details?id=com.outthinking.bgeraser of feature in android java code remove the background.

My code is :

public class FingerText extends Activity
     {

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(new MyView(this));

    mPaint = new Paint();
    mPaint.setAntiAlias(true);
    mPaint.setDither(true);
    //this is the line that sets the initial pen color
    mPaint.setColor(inkColor);
    mPaint.setStyle(Paint.Style.STROKE);
    mPaint.setStrokeJoin(Paint.Join.ROUND);
    mPaint.setStrokeCap(Paint.Cap.ROUND);
    mPaint.setStrokeWidth(2);
}


private Paint mPaint;
private Bitmap mBitmap;
private boolean inkChosen;
private int bgColor = 0x00000000;  //set initial bg color var to white
private int inkColor = 0xFF000000; //set initial ink color var to black

public void colorChanged(int color) {
    //This is the implementation of the interface from colorpickerdialog.java

    if (inkChosen) {
        mPaint.setColor(color);
        inkColor = color;
    } else {
        mBitmap.eraseColor(color);
        bgColor = color;
        //set the color to the user's last ink color choice
        mPaint.setColor(inkColor);
    }


}

public class MyView extends View {


    private Canvas mCanvas;
    private Path mPath;
    private Paint mBitmapPaint;

    public MyView(Context c) {
        super(c);

        mBitmap = Bitmap.createBitmap(320, 480, Bitmap.Config.ARGB_8888);

        //this sets the bg color for the bitmap
        mBitmap.eraseColor(bgColor);
        mCanvas = new Canvas(mBitmap);
        mPath = new Path();
        mBitmapPaint = new Paint(Paint.DITHER_FLAG);
    }

    @Override
    protected void onSizeChanged(int w, int h, int oldw, int oldh) {
        super.onSizeChanged(w, h, oldw, oldh);
    }

    @Override
    protected void onDraw(Canvas canvas) {
        //this is the line that changes the bg color in the initial canvas
        canvas.drawColor(bgColor);
        canvas.drawBitmap(mBitmap, 0, 0, mBitmapPaint);

        canvas.drawPath(mPath, mPaint);
        canvas.drawBitmap(((BitmapDrawable)getResources().getDrawable(
                R.drawable.ic_alphabets)).getBitmap(),0, 0, mBitmapPaint);
    }

    private float mX, mY;
    private static final float TOUCH_TOLERANCE = 4;

    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);
        // commit the path to our offscreen
        mCanvas.drawPath(mPath, mPaint);
        // kill this so we don't double draw
        mPath.reset();
    }

    @Override
    public boolean onTouchEvent(MotionEvent event) {
        float x = event.getX();
        float y = event.getY();

        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;
    }
}

private static final int BG_COLOR_ID = Menu.FIRST;
private static final int INK_MENU_ID = Menu.FIRST + 1;
private static final int CLEAR_MENU_ID = Menu.FIRST + 2;
private static final int ERASER_MENU_ID = Menu.FIRST + 3;
private static final int SEND_MENU_ID = Menu.FIRST + 4;

@Override
public boolean onCreateOptionsMenu(Menu menu) {
    super.onCreateOptionsMenu(menu);

    menu.add(0, BG_COLOR_ID, 0, "Background Color").setShortcut('3', 'b');
    menu.add(0, INK_MENU_ID, 0, "Ink Color").setShortcut('4', 'c');
    menu.add(0, CLEAR_MENU_ID, 0, "Clear All").setShortcut('5', 'e');
    menu.add(0, ERASER_MENU_ID, 0, "Eraser").setShortcut('6', 'x');
    menu.add(0, SEND_MENU_ID, 0, "Send").setShortcut('7', 's');


    return true;
}

@Override
public boolean onPrepareOptionsMenu(Menu menu) {
    super.onPrepareOptionsMenu(menu);
    return true;
}

@Override
public boolean onOptionsItemSelected(MenuItem item) {
    mPaint.setXfermode(null);
    mPaint.setAlpha(0xFF);

    switch (item.getItemId()) {

        case BG_COLOR_ID:
            inkChosen = false;
            return true;
        case INK_MENU_ID:
            inkColor = mPaint.getColor();
            inkChosen = true;
            return true;
        case CLEAR_MENU_ID:
            mBitmap.eraseColor(bgColor);
            return true;
        case ERASER_MENU_ID:
            //set pen color to bg color for 'erasing'
            mPaint.setColor(bgColor);
            return true;
        case SEND_MENU_ID:

            FileInputStream ifs;
            try {
                FileOutputStream fs = openFileOutput("message_image", Context.MODE_PRIVATE);
                mBitmap.compress(Bitmap.CompressFormat.PNG, 100, fs);
                ifs = openFileInput("message_image");
            } catch (FileNotFoundException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
                return true;
            }
            // inserts file pointed to by ifs into image gallery
            String url = MediaStore.Images.Media.insertImage(getContentResolver(),
                    BitmapFactory.decodeStream(ifs),
                    "Message image1", "Message image");

            Intent sendIntent = new Intent(Intent.ACTION_SEND);
            sendIntent.putExtra("sms_body", "Message created using FingerText");
            sendIntent.putExtra(Intent.EXTRA_STREAM, Uri.parse(url));
            sendIntent.setType("image/png");
            startActivity(sendIntent);
            bgColor = 0xFFFFFFFF;  //set bg color var back to white
            inkColor = 0xFF000000; //set ink color var back to black
            mBitmap.eraseColor(bgColor);
            return true;
    }
    return super.onOptionsItemSelected(item);
}
}

Please Help Me Thanks in advance.

Answer 1

i am done it here is my code use as it is:

public class DrawView extends View implements View.OnTouchListener {
private ArrayList<PathPoints> paths = new ArrayList<PathPoints>();
private ArrayList<PathPoints> undonePaths = new ArrayList<PathPoints>();
private Path mPath;
private int x = 0;
private int y = 0;

Bitmap bitmap;
Bitmap bitmap2;
Canvas bitmapCanvas;

Drawable d;

private final Paint paint = new Paint();
private final Paint eraserPaint = new Paint();

Matrix matrix;

// We can be in one of these 3 states
static final int NONE = 0;
static final int DRAG = 1;
static final int ZOOM = 2;
int mode = NONE;

// Remember some things for zooming
PointF last = new PointF();
PointF start = new PointF();
float minScale = 1f;
float maxScale = 3f;
float[] m;

int viewWidth, viewHeight;
static final int CLICK = 3;
float saveScale = 1f;
protected float origWidth, origHeight;
int oldMeasuredWidth, oldMeasuredHeight;

ScaleGestureDetector mScaleDetector;

Context context;

public DrawView(Context context) {
    super(context);
    setFocusable(true);
    setFocusableInTouchMode(true);

    this.setOnTouchListener(this);

    // Set background
    this.setBackgroundResource(R.drawable.transparentbg);

    // Set bitmap
    bitmap = BitmapFactory.decodeResource(getResources(), R.drawable.shert).copy(Bitmap.Config.ARGB_8888, true);
    bitmap = Bitmap.createScaledBitmap(bitmap, 600, 900, true);

    bitmapCanvas = new Canvas();
    bitmapCanvas.setBitmap(bitmap);//Bitmap.createScaledBitmap(bitmap, 350,400, true)

    bitmapCanvas.drawColor(Color.TRANSPARENT);

    // Set eraser paint properties
    eraserPaint.setColor(Color.TRANSPARENT);
    eraserPaint.setAlpha(0);
    eraserPaint.setXfermode(new PorterDuffXfermode(PorterDuff.Mode.DST_IN));
    eraserPaint.setAntiAlias(true);
    mPath = new Path();
    paths.add(new PathPoints(mPath, Color.TRANSPARENT, false));

}

@Override
public void onDraw(Canvas canvas) {
    canvas.drawColor(Color.TRANSPARENT);
    bitmapCanvas.drawColor(Color.TRANSPARENT);
    bitmapCanvas.drawCircle(x, y, 20, eraserPaint);

    canvas.drawBitmap(bitmap, 0, 0, paint);


}

public boolean onTouch(View view, MotionEvent event) {
    x = (int) event.getX();
    y = (int) event.getY();
    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;
}

private float mX, mY;
private static final float TOUCH_TOLERANCE = 0;

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);
    // commit the path to our offscreen
    bitmapCanvas.drawPath(mPath, eraserPaint);
    // kill this so we don't double draw
    mPath = new Path();
    paths.add(new PathPoints(mPath, Color.TRANSPARENT, false));

}

public static Bitmap scaleDown(Bitmap realImage, float maxImageSize,
                               boolean filter) {
    float ratio = Math.min(
            (float) maxImageSize / realImage.getWidth(),
            (float) maxImageSize / realImage.getHeight());
    int width = Math.round((float) ratio * realImage.getWidth());
    int height = Math.round((float) ratio * realImage.getHeight());

    Bitmap newBitmap = Bitmap.createScaledBitmap(realImage, width,
            height, filter);
    return newBitmap;
}




void fixTrans() {
    matrix.getValues(m);
    float transX = m[Matrix.MTRANS_X];
    float transY = m[Matrix.MTRANS_Y];

    float fixTransX = getFixTrans(transX, viewWidth, origWidth * saveScale);
    float fixTransY = getFixTrans(transY, viewHeight, origHeight
            * saveScale);

    if (fixTransX != 0 || fixTransY != 0)
        matrix.postTranslate(fixTransX, fixTransY);
}

float getFixTrans(float trans, float viewSize, float contentSize) {
    float minTrans, maxTrans;

    if (contentSize <= viewSize) {
        minTrans = 0;
        maxTrans = viewSize - contentSize;
    } else {
        minTrans = viewSize - contentSize;
        maxTrans = 0;
    }

    if (trans < minTrans)
        return -trans + minTrans;
    if (trans > maxTrans)
        return -trans + maxTrans;
    return 0;
}

float getFixDragTrans(float delta, float viewSize, float contentSize) {
    if (contentSize <= viewSize) {
        return 0;
    }
    return delta;
}


public void onClickUndo() {
    if (paths.size() > 0) {
        undonePaths.add(paths.remove(paths.size() - 1));
        invalidate();
    } else {

    }
    // toast the user
}

public void onClickRedo() {
    if (undonePaths.size() > 0) {
        paths.add(undonePaths.remove(undonePaths.size() - 1));
        invalidate();
    } else {

    }
    // toast the user
}

class PathPoints {
    private Path path;
    // private Paint eraserPaint;
    private int color;
    private String textToDraw;
    private boolean isTextToDraw;
    private int x, y;

    public PathPoints(Path path, int color, boolean isTextToDraw) {
        this.path = path;
        this.color = color;
        this.isTextToDraw = isTextToDraw;
    }

    public PathPoints(int color, String textToDraw, boolean isTextToDraw,
                      int x, int y) {
        this.color = color;
        this.textToDraw = textToDraw;
        this.isTextToDraw = isTextToDraw;
        this.x = x;
        this.y = y;
    }

    public Path getPath() {
        return path;
    }

    public void setPath(Path path) {
        this.path = path;
    }

    public int getColor() {
        return color;
    }

    public void setColor(int color) {
        this.color = color;
    }

    public String getTextToDraw() {
        return textToDraw;
    }

    public void setTextToDraw(String textToDraw) {
        this.textToDraw = textToDraw;
    }

    public boolean isTextToDraw() {
        return isTextToDraw;
    }

    public void setTextToDraw(boolean isTextToDraw) {
        this.isTextToDraw = isTextToDraw;
    }

    public int getX() {
        return x;
    }

    public void setX(int x) {
        this.x = x;
    }

    public int getY() {
        return y;
    }

    public void setY(int y) {
        this.y = y;
    }

}

}

This code is working in my live project thanks.