| | |
|---|
| | |
|
|---|
| | | import android.graphics.Bitmap;
|
|---|
| | | import android.graphics.Canvas;
|
|---|
| | | import android.graphics.Color;
|
|---|
| | | import android.graphics.Paint;
|
|---|
| | | import android.graphics.Path;
|
|---|
| | | import android.graphics.PorterDuff;
|
|---|
| | | import android.graphics.PorterDuffXfermode;
|
|---|
| | | import android.graphics.Rect;
|
|---|
| | |
|---|
| | | return output;
|
|---|
| | | }
|
|---|
| | |
|
|---|
| | | public static Bitmap getCornerBitmap(Bitmap bitmap) {
|
|---|
| | | int min = bitmap.getWidth() > bitmap.getHeight() ? bitmap.getHeight() : bitmap.getWidth();
|
|---|
| | | public static Bitmap getCornerBitmap(Bitmap mBitmap) {
|
|---|
| | | // int min = bitmap.getWidth() > bitmap.getHeight() ? bitmap.getHeight() : bitmap.getWidth();
|
|---|
| | | //
|
|---|
| | | // int width = bitmap.getWidth();
|
|---|
| | | // int height = bitmap.getHeight();
|
|---|
| | | //
|
|---|
| | | // Bitmap output = Bitmap.createBitmap(width,
|
|---|
| | | // height, Bitmap.Config.ARGB_8888);
|
|---|
| | | // Canvas canvas = new Canvas(output);
|
|---|
| | | //
|
|---|
| | | // final int color = 0xff424242;
|
|---|
| | | // final Paint paint = new Paint();
|
|---|
| | | // final RectF rectF = new RectF(0, 0, width, height);
|
|---|
| | | // final Rect rect = new Rect(0, 0, width, height);
|
|---|
| | | //
|
|---|
| | | // paint.setAntiAlias(true);
|
|---|
| | | // canvas.drawARGB(0, 0, 0, 0);
|
|---|
| | | // paint.setColor(color);
|
|---|
| | | // //canvas.drawCircle(min / 2, min / 2, min / 2, paint);
|
|---|
| | | // canvas.drawRoundRect(rectF, 333, 333, paint);
|
|---|
| | | // paint.setXfermode(new PorterDuffXfermode(PorterDuff.Mode.SRC_IN));
|
|---|
| | | // canvas.drawBitmap(bitmap, rect, rect, paint);
|
|---|
| | | //
|
|---|
| | | // return output;
|
|---|
| | | // Create a rounded corners bitmap
|
|---|
| | | // mBitmap = getRoundedBitmap(mBitmap, cornerRadius);
|
|---|
| | | //
|
|---|
| | | // // Add a border around rounded corners bitmap
|
|---|
| | | // mBitmap = addBorderToRoundedBitmap(mBitmap, cornerRadius, 10, Color.WHITE);
|
|---|
| | | //
|
|---|
| | | // // Add a border around rounded corners bitmap as shadow
|
|---|
| | | // mBitmap = addBorderToRoundedBitmap(mBitmap, cornerRadius, 3, Color.LTGRAY);
|
|---|
| | | return mBitmap;
|
|---|
| | | }
|
|---|
| | |
|
|---|
| | | int width = bitmap.getWidth();
|
|---|
| | | int height = bitmap.getHeight();
|
|---|
| | | public static Bitmap getRoundedCornerBitmap(Bitmap mBitmap, int cornerRadius) {
|
|---|
| | | // Bitmap output = Bitmap.createBitmap(bitmap.getWidth(), bitmap
|
|---|
| | | // .getHeight(), Bitmap.Config.ARGB_8888);
|
|---|
| | | // Canvas canvas = new Canvas(output);
|
|---|
| | | //
|
|---|
| | | // final int color = 0xff424242;
|
|---|
| | | // final Paint paint = new Paint();
|
|---|
| | | // final Rect rect = new Rect(0, 0, bitmap.getWidth(), bitmap.getHeight());
|
|---|
| | | // final RectF rectF = new RectF(rect);
|
|---|
| | | // final float roundPx = pixels;
|
|---|
| | | //
|
|---|
| | | // paint.setAntiAlias(true);
|
|---|
| | | // canvas.drawARGB(0, 0, 0, 0);
|
|---|
| | | // paint.setColor(color);
|
|---|
| | | // canvas.drawRoundRect(rectF, roundPx, roundPx, paint);
|
|---|
| | | //
|
|---|
| | | // paint.setXfermode(new PorterDuffXfermode(PorterDuff.Mode.SRC_IN));
|
|---|
| | | // canvas.drawBitmap(bitmap, rect, rect, paint);
|
|---|
| | | //
|
|---|
| | | // return output;
|
|---|
| | |
|
|---|
| | | Bitmap output = Bitmap.createBitmap(width,
|
|---|
| | | height, Bitmap.Config.ARGB_8888);
|
|---|
| | | Canvas canvas = new Canvas(output);
|
|---|
| | | BitmapUtil bitmapUtil = new BitmapUtil();
|
|---|
| | |
|
|---|
| | | final int color = 0xff424242;
|
|---|
| | | final Paint paint = new Paint();
|
|---|
| | | final RectF rectF = new RectF(0, 0, width, height);
|
|---|
| | | final Rect rect = new Rect(0, 0, width, height);
|
|---|
| | | mBitmap = mBitmap.copy(mBitmap.getConfig(), true);
|
|---|
| | |
|
|---|
| | | mBitmap = bitmapUtil.getRoundedBitmap(mBitmap, cornerRadius);
|
|---|
| | |
|
|---|
| | | // Add a border around rounded corners bitmap
|
|---|
| | | mBitmap = bitmapUtil.addBorderToRoundedBitmap(mBitmap, cornerRadius, 10, Color.WHITE);
|
|---|
| | |
|
|---|
| | | // Add a border around rounded corners bitmap as shadow
|
|---|
| | | mBitmap = bitmapUtil.addBorderToRoundedBitmap(mBitmap, cornerRadius, 3, Color.LTGRAY);
|
|---|
| | | return mBitmap;
|
|---|
| | | }
|
|---|
| | |
|
|---|
| | | public static Path RoundedRect(
|
|---|
| | | float left, float top, float right, float bottom, float rx, float ry,
|
|---|
| | | boolean tl, boolean tr, boolean br, boolean bl
|
|---|
| | | ){
|
|---|
| | | Path path = new Path();
|
|---|
| | | if (rx < 0) rx = 0;
|
|---|
| | | if (ry < 0) ry = 0;
|
|---|
| | | float width = right - left;
|
|---|
| | | float height = bottom - top;
|
|---|
| | | if (rx > width / 2) rx = width / 2;
|
|---|
| | | if (ry > height / 2) ry = height / 2;
|
|---|
| | | float widthMinusCorners = (width - (2 * rx));
|
|---|
| | | float heightMinusCorners = (height - (2 * ry));
|
|---|
| | |
|
|---|
| | | path.moveTo(right, top + ry);
|
|---|
| | | if (tr)
|
|---|
| | | path.rQuadTo(0, -ry, -rx, -ry);//top-right corner
|
|---|
| | | else{
|
|---|
| | | path.rLineTo(0, -ry);
|
|---|
| | | path.rLineTo(-rx,0);
|
|---|
| | | }
|
|---|
| | | path.rLineTo(-widthMinusCorners, 0);
|
|---|
| | | if (tl)
|
|---|
| | | path.rQuadTo(-rx, 0, -rx, ry); //top-left corner
|
|---|
| | | else{
|
|---|
| | | path.rLineTo(-rx, 0);
|
|---|
| | | path.rLineTo(0,ry);
|
|---|
| | | }
|
|---|
| | | path.rLineTo(0, heightMinusCorners);
|
|---|
| | |
|
|---|
| | | if (bl)
|
|---|
| | | path.rQuadTo(0, ry, rx, ry);//bottom-left corner
|
|---|
| | | else{
|
|---|
| | | path.rLineTo(0, ry);
|
|---|
| | | path.rLineTo(rx,0);
|
|---|
| | | }
|
|---|
| | |
|
|---|
| | | path.rLineTo(widthMinusCorners, 0);
|
|---|
| | | if (br)
|
|---|
| | | path.rQuadTo(rx, 0, rx, -ry); //bottom-right corner
|
|---|
| | | else{
|
|---|
| | | path.rLineTo(rx,0);
|
|---|
| | | path.rLineTo(0, -ry);
|
|---|
| | | }
|
|---|
| | |
|
|---|
| | | path.rLineTo(0, -heightMinusCorners);
|
|---|
| | |
|
|---|
| | | path.close();//Given close, last lineto can be removed.
|
|---|
| | |
|
|---|
| | | return path;
|
|---|
| | | }
|
|---|
| | |
|
|---|
| | | // Custom method to create rounded bitmap from a rectangular bitmap
|
|---|
| | | public Bitmap getRoundedBitmap(Bitmap srcBitmap, int cornerRadius) {
|
|---|
| | | // Initialize a new instance of Bitmap
|
|---|
| | | Bitmap dstBitmap = Bitmap.createBitmap(
|
|---|
| | | srcBitmap.getWidth(), // Width
|
|---|
| | | srcBitmap.getHeight(), // Height
|
|---|
| | |
|
|---|
| | | Bitmap.Config.ARGB_8888 // Config
|
|---|
| | | );
|
|---|
| | |
|
|---|
| | | /*
|
|---|
| | | Canvas
|
|---|
| | | The Canvas class holds the "draw" calls. To draw something, you need 4 basic
|
|---|
| | | components: A Bitmap to hold the pixels, a Canvas to host the draw calls (writing
|
|---|
| | | into the bitmap), a drawing primitive (e.g. Rect, Path, text, Bitmap), and a paint
|
|---|
| | | (to describe the colors and styles for the drawing).
|
|---|
| | | */
|
|---|
| | | // Initialize a new Canvas to draw rounded bitmap
|
|---|
| | | Canvas canvas = new Canvas(dstBitmap);
|
|---|
| | |
|
|---|
| | | // Initialize a new Paint instance
|
|---|
| | | Paint paint = new Paint();
|
|---|
| | | paint.setAntiAlias(true);
|
|---|
| | | canvas.drawARGB(0, 0, 0, 0);
|
|---|
| | | paint.setColor(color);
|
|---|
| | | //canvas.drawCircle(min / 2, min / 2, min / 2, paint);
|
|---|
| | | canvas.drawRoundRect(rectF, 333, 333, paint);
|
|---|
| | | paint.setXfermode(new PorterDuffXfermode(PorterDuff.Mode.SRC_IN));
|
|---|
| | | canvas.drawBitmap(bitmap, rect, rect, paint);
|
|---|
| | |
|
|---|
| | | return output;
|
|---|
| | | /*
|
|---|
| | | Rect
|
|---|
| | | Rect holds four integer coordinates for a rectangle. The rectangle is represented by
|
|---|
| | | the coordinates of its 4 edges (left, top, right bottom). These fields can be accessed
|
|---|
| | | directly. Use width() and height() to retrieve the rectangle's width and height.
|
|---|
| | | Note: most methods do not check to see that the coordinates are sorted correctly
|
|---|
| | | (i.e. left <= right and top <= bottom).
|
|---|
| | | */
|
|---|
| | | /*
|
|---|
| | | Rect(int left, int top, int right, int bottom)
|
|---|
| | | Create a new rectangle with the specified coordinates.
|
|---|
| | | */
|
|---|
| | | // Initialize a new Rect instance
|
|---|
| | | Rect rect = new Rect(0, 0, srcBitmap.getWidth(), srcBitmap.getHeight());
|
|---|
| | |
|
|---|
| | | /*
|
|---|
| | | RectF
|
|---|
| | | RectF holds four float coordinates for a rectangle. The rectangle is represented by
|
|---|
| | | the coordinates of its 4 edges (left, top, right bottom). These fields can be
|
|---|
| | | accessed directly. Use width() and height() to retrieve the rectangle's width and
|
|---|
| | | height. Note: most methods do not check to see that the coordinates are sorted
|
|---|
| | | correctly (i.e. left <= right and top <= bottom).
|
|---|
| | | */
|
|---|
| | | // Initialize a new RectF instance
|
|---|
| | | RectF rectF = new RectF(rect);
|
|---|
| | |
|
|---|
| | | /*
|
|---|
| | | public void drawRoundRect (RectF rect, float rx, float ry, Paint paint)
|
|---|
| | | Draw the specified round-rect using the specified paint. The roundrect will be
|
|---|
| | | filled or framed based on the Style in the paint.
|
|---|
| | |
|
|---|
| | | Parameters
|
|---|
| | | rect : The rectangular bounds of the roundRect to be drawn
|
|---|
| | | rx : The x-radius of the oval used to round the corners
|
|---|
| | | ry : The y-radius of the oval used to round the corners
|
|---|
| | | paint : The paint used to draw the roundRect
|
|---|
| | | */
|
|---|
| | | // Draw a rounded rectangle object on canvas
|
|---|
| | | canvas.drawRoundRect(rectF, cornerRadius, cornerRadius, paint);
|
|---|
| | |
|
|---|
| | | /*
|
|---|
| | | public Xfermode setXfermode (Xfermode xfermode)
|
|---|
| | | Set or clear the xfermode object.
|
|---|
| | | Pass null to clear any previous xfermode. As a convenience, the parameter passed
|
|---|
| | | is also returned.
|
|---|
| | |
|
|---|
| | | Parameters
|
|---|
| | | xfermode : May be null. The xfermode to be installed in the paint
|
|---|
| | | Returns
|
|---|
| | | xfermode
|
|---|
| | | */
|
|---|
| | | /*
|
|---|
| | | public PorterDuffXfermode (PorterDuff.Mode mode)
|
|---|
| | | Create an xfermode that uses the specified porter-duff mode.
|
|---|
| | |
|
|---|
| | | Parameters
|
|---|
| | | mode : The porter-duff mode that is applied
|
|---|
| | |
|
|---|
| | | */
|
|---|
| | | paint.setXfermode(new PorterDuffXfermode(PorterDuff.Mode.SRC_IN));
|
|---|
| | |
|
|---|
| | | /*
|
|---|
| | | public void drawBitmap (Bitmap bitmap, float left, float top, Paint paint)
|
|---|
| | | Draw the specified bitmap, with its top/left corner at (x,y), using the specified
|
|---|
| | | paint, transformed by the current matrix.
|
|---|
| | |
|
|---|
| | | Note: if the paint contains a maskfilter that generates a mask which extends beyond
|
|---|
| | | the bitmap's original width/height (e.g. BlurMaskFilter), then the bitmap will be
|
|---|
| | | drawn as if it were in a Shader with CLAMP mode. Thus the color outside of the
|
|---|
| | | original width/height will be the edge color replicated.
|
|---|
| | |
|
|---|
| | | If the bitmap and canvas have different densities, this function will take care of
|
|---|
| | | automatically scaling the bitmap to draw at the same density as the canvas.
|
|---|
| | |
|
|---|
| | | Parameters
|
|---|
| | | bitmap : The bitmap to be drawn
|
|---|
| | | left : The position of the left side of the bitmap being drawn
|
|---|
| | | top : The position of the top side of the bitmap being drawn
|
|---|
| | | paint : The paint used to draw the bitmap (may be null)
|
|---|
| | | */
|
|---|
| | | // Make a rounded image by copying at the exact center position of source image
|
|---|
| | | canvas.drawBitmap(srcBitmap, 0, 0, paint);
|
|---|
| | |
|
|---|
| | | // Free the native object associated with this bitmap.
|
|---|
| | | srcBitmap.recycle();
|
|---|
| | |
|
|---|
| | | // Return the circular bitmap
|
|---|
| | | return dstBitmap;
|
|---|
| | | }
|
|---|
| | |
|
|---|
| | | // Custom method to add a border around rounded bitmap
|
|---|
| | | public Bitmap addBorderToRoundedBitmap(Bitmap srcBitmap, int cornerRadius, int borderWidth, int borderColor){
|
|---|
| | | // We will hide half border by bitmap
|
|---|
| | | borderWidth = borderWidth*2;
|
|---|
| | |
|
|---|
| | | // Initialize a new Bitmap to make it bordered rounded bitmap
|
|---|
| | | Bitmap dstBitmap = Bitmap.createBitmap(
|
|---|
| | | srcBitmap.getWidth() + borderWidth, // Width
|
|---|
| | | srcBitmap.getHeight() + borderWidth, // Height
|
|---|
| | | Bitmap.Config.ARGB_8888 // Config
|
|---|
| | | );
|
|---|
| | |
|
|---|
| | | // Initialize a new Canvas instance
|
|---|
| | | Canvas canvas = new Canvas(dstBitmap);
|
|---|
| | |
|
|---|
| | | // Initialize a new Paint instance to draw border
|
|---|
| | | Paint paint = new Paint();
|
|---|
| | | paint.setColor(borderColor);
|
|---|
| | | paint.setStyle(Paint.Style.STROKE);
|
|---|
| | | paint.setStrokeWidth(borderWidth);
|
|---|
| | | paint.setAntiAlias(true);
|
|---|
| | |
|
|---|
| | | // Initialize a new Rect instance
|
|---|
| | | Rect rect = new Rect(
|
|---|
| | | borderWidth/2,
|
|---|
| | | borderWidth/2,
|
|---|
| | | dstBitmap.getWidth() - borderWidth/2,
|
|---|
| | | dstBitmap.getHeight() - borderWidth/2
|
|---|
| | | );
|
|---|
| | |
|
|---|
| | | // Initialize a new instance of RectF;
|
|---|
| | | RectF rectF = new RectF(rect);
|
|---|
| | |
|
|---|
| | | // Draw rounded rectangle as a border/shadow on canvas
|
|---|
| | | canvas.drawRoundRect(rectF,cornerRadius,cornerRadius,paint);
|
|---|
| | |
|
|---|
| | | // Draw source bitmap to canvas
|
|---|
| | | canvas.drawBitmap(srcBitmap, borderWidth / 2, borderWidth / 2, null);
|
|---|
| | |
|
|---|
| | | /*
|
|---|
| | | public void recycle ()
|
|---|
| | | Free the native object associated with this bitmap, and clear the reference to the
|
|---|
| | | pixel data. This will not free the pixel data synchronously; it simply allows it to
|
|---|
| | | be garbage collected if there are no other references. The bitmap is marked as
|
|---|
| | | "dead", meaning it will throw an exception if getPixels() or setPixels() is called,
|
|---|
| | | and will draw nothing. This operation cannot be reversed, so it should only be
|
|---|
| | | called if you are sure there are no further uses for the bitmap. This is an advanced
|
|---|
| | | call, and normally need not be called, since the normal GC process will free up this
|
|---|
| | | memory when there are no more references to this bitmap.
|
|---|
| | | */
|
|---|
| | | srcBitmap.recycle();
|
|---|
| | |
|
|---|
| | | // Return the bordered circular bitmap
|
|---|
| | | return dstBitmap;
|
|---|
| | | }
|
|---|
| | |
|
|---|
| | | }
|
|---|
