From 053bef92d3ad2caa71d66ce0817bae51f7e2a64e Mon Sep 17 00:00:00 2001
From: xuxiuxi <xuxiuxi@454eff88-639b-444f-9e54-f578c98de674>
Date: 星期五, 11 八月 2017 16:04:28 +0800
Subject: [PATCH]
---
VisitFace/DemoForBsk/app/src/main/java/cn/com/basic/face/util/BitmapUtil.java | 297 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
1 files changed, 297 insertions(+), 0 deletions(-)
diff --git a/VisitFace/DemoForBsk/app/src/main/java/cn/com/basic/face/util/BitmapUtil.java b/VisitFace/DemoForBsk/app/src/main/java/cn/com/basic/face/util/BitmapUtil.java
index 519521d..ee8f3a8 100644
--- a/VisitFace/DemoForBsk/app/src/main/java/cn/com/basic/face/util/BitmapUtil.java
+++ b/VisitFace/DemoForBsk/app/src/main/java/cn/com/basic/face/util/BitmapUtil.java
@@ -2,10 +2,15 @@
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;
+import android.graphics.RectF;
+
+import cn.com.basic.face.base.MainActivity;
public class BitmapUtil {
@@ -30,4 +35,296 @@
return output;
}
+ 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;
+ }
+
+ 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;
+
+ BitmapUtil bitmapUtil = new BitmapUtil();
+
+ 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);
+
+ /*
+ 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;
+ }
+
}
--
Gitblit v1.8.0