Last active
December 17, 2015 23:49
-
-
Save NLMartian/5692374 to your computer and use it in GitHub Desktop.
Android 图片基本处理代码段
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
public class ImageUtil { | |
/** | |
* 图片变灰 | |
* @param bmpOriginal | |
* @return | |
*/ | |
public static Bitmap toGrayscale(Bitmap bmpOriginal) { | |
int width, height; | |
height = bmpOriginal.getHeight(); | |
width = bmpOriginal.getWidth(); | |
Bitmap bmpGrayscale = Bitmap.createBitmap(width, height, Bitmap.Config.ARGB_8888); | |
Canvas c = new Canvas(bmpGrayscale); | |
Paint paint = new Paint(); | |
ColorMatrix cm = new ColorMatrix(); | |
cm.setSaturation(0); | |
ColorMatrixColorFilter f = new ColorMatrixColorFilter(cm); | |
paint.setColorFilter(f); | |
c.drawBitmap(bmpOriginal, 0, 0, paint); | |
return bmpGrayscale; | |
} | |
// 对Bitmap做高斯模糊处理 | |
public static Bitmap fastblur(Bitmap sentBitmap, int radius) { | |
// Stack Blur v1.0 from | |
// http://www.quasimondo.com/StackBlurForCanvas/StackBlurDemo.html | |
// | |
// Java Author: Mario Klingemann <mario at quasimondo.com> | |
// http://incubator.quasimondo.com | |
// created Feburary 29, 2004 | |
// Android port : Yahel Bouaziz <yahel at kayenko.com> | |
// http://www.kayenko.com | |
// ported april 5th, 2012 | |
// This is a compromise between Gaussian Blur and Box blur | |
// It creates much better looking blurs than Box Blur, but is | |
// 7x faster than my Gaussian Blur implementation. | |
// | |
// I called it Stack Blur because this describes best how this | |
// filter works internally: it creates a kind of moving stack | |
// of colors whilst scanning through the image. Thereby it | |
// just has to add one new block of color to the right side | |
// of the stack and remove the leftmost color. The remaining | |
// colors on the topmost layer of the stack are either added on | |
// or reduced by one, depending on if they are on the right or | |
// on the left side of the stack. | |
// | |
// If you are using this algorithm in your code please add | |
// the following line: | |
// | |
// Stack Blur Algorithm by Mario Klingemann <mario@quasimondo.com> | |
Bitmap bitmap = sentBitmap.copy(sentBitmap.getConfig(), true); | |
if (radius < 1) { | |
return (null); | |
} | |
int w = bitmap.getWidth(); | |
int h = bitmap.getHeight(); | |
int[] pix = new int[w * h]; | |
Log.e("pix", w + " " + h + " " + pix.length); | |
bitmap.getPixels(pix, 0, w, 0, 0, w, h); | |
int wm = w - 1; | |
int hm = h - 1; | |
int wh = w * h; | |
int div = radius + radius + 1; | |
int r[] = new int[wh]; | |
int g[] = new int[wh]; | |
int b[] = new int[wh]; | |
int rsum, gsum, bsum, x, y, i, p, yp, yi, yw; | |
int vmin[] = new int[Math.max(w, h)]; | |
int divsum = (div + 1) >> 1; | |
divsum *= divsum; | |
int dv[] = new int[256 * divsum]; | |
for (i = 0; i < 256 * divsum; i++) { | |
dv[i] = (i / divsum); | |
} | |
yw = yi = 0; | |
int[][] stack = new int[div][3]; | |
int stackpointer; | |
int stackstart; | |
int[] sir; | |
int rbs; | |
int r1 = radius + 1; | |
int routsum, goutsum, boutsum; | |
int rinsum, ginsum, binsum; | |
for (y = 0; y < h; y++) { | |
rinsum = ginsum = binsum = routsum = goutsum = boutsum = rsum = gsum = bsum = 0; | |
for (i = -radius; i <= radius; i++) { | |
p = pix[yi + Math.min(wm, Math.max(i, 0))]; | |
sir = stack[i + radius]; | |
sir[0] = (p & 0xff0000) >> 16; | |
sir[1] = (p & 0x00ff00) >> 8; | |
sir[2] = (p & 0x0000ff); | |
rbs = r1 - Math.abs(i); | |
rsum += sir[0] * rbs; | |
gsum += sir[1] * rbs; | |
bsum += sir[2] * rbs; | |
if (i > 0) { | |
rinsum += sir[0]; | |
ginsum += sir[1]; | |
binsum += sir[2]; | |
} else { | |
routsum += sir[0]; | |
goutsum += sir[1]; | |
boutsum += sir[2]; | |
} | |
} | |
stackpointer = radius; | |
for (x = 0; x < w; x++) { | |
r[yi] = dv[rsum]; | |
g[yi] = dv[gsum]; | |
b[yi] = dv[bsum]; | |
rsum -= routsum; | |
gsum -= goutsum; | |
bsum -= boutsum; | |
stackstart = stackpointer - radius + div; | |
sir = stack[stackstart % div]; | |
routsum -= sir[0]; | |
goutsum -= sir[1]; | |
boutsum -= sir[2]; | |
if (y == 0) { | |
vmin[x] = Math.min(x + radius + 1, wm); | |
} | |
p = pix[yw + vmin[x]]; | |
sir[0] = (p & 0xff0000) >> 16; | |
sir[1] = (p & 0x00ff00) >> 8; | |
sir[2] = (p & 0x0000ff); | |
rinsum += sir[0]; | |
ginsum += sir[1]; | |
binsum += sir[2]; | |
rsum += rinsum; | |
gsum += ginsum; | |
bsum += binsum; | |
stackpointer = (stackpointer + 1) % div; | |
sir = stack[(stackpointer) % div]; | |
routsum += sir[0]; | |
goutsum += sir[1]; | |
boutsum += sir[2]; | |
rinsum -= sir[0]; | |
ginsum -= sir[1]; | |
binsum -= sir[2]; | |
yi++; | |
} | |
yw += w; | |
} | |
for (x = 0; x < w; x++) { | |
rinsum = ginsum = binsum = routsum = goutsum = boutsum = rsum = gsum = bsum = 0; | |
yp = -radius * w; | |
for (i = -radius; i <= radius; i++) { | |
yi = Math.max(0, yp) + x; | |
sir = stack[i + radius]; | |
sir[0] = r[yi]; | |
sir[1] = g[yi]; | |
sir[2] = b[yi]; | |
rbs = r1 - Math.abs(i); | |
rsum += r[yi] * rbs; | |
gsum += g[yi] * rbs; | |
bsum += b[yi] * rbs; | |
if (i > 0) { | |
rinsum += sir[0]; | |
ginsum += sir[1]; | |
binsum += sir[2]; | |
} else { | |
routsum += sir[0]; | |
goutsum += sir[1]; | |
boutsum += sir[2]; | |
} | |
if (i < hm) { | |
yp += w; | |
} | |
} | |
yi = x; | |
stackpointer = radius; | |
for (y = 0; y < h; y++) { | |
// Preserve alpha channel: ( 0xff000000 & pix[yi] ) | |
pix[yi] = ( 0xff000000 & pix[yi] ) | ( dv[rsum] << 16 ) | ( dv[gsum] << 8 ) | dv[bsum]; | |
rsum -= routsum; | |
gsum -= goutsum; | |
bsum -= boutsum; | |
stackstart = stackpointer - radius + div; | |
sir = stack[stackstart % div]; | |
routsum -= sir[0]; | |
goutsum -= sir[1]; | |
boutsum -= sir[2]; | |
if (x == 0) { | |
vmin[y] = Math.min(y + r1, hm) * w; | |
} | |
p = x + vmin[y]; | |
sir[0] = r[p]; | |
sir[1] = g[p]; | |
sir[2] = b[p]; | |
rinsum += sir[0]; | |
ginsum += sir[1]; | |
binsum += sir[2]; | |
rsum += rinsum; | |
gsum += ginsum; | |
bsum += binsum; | |
stackpointer = (stackpointer + 1) % div; | |
sir = stack[stackpointer]; | |
routsum += sir[0]; | |
goutsum += sir[1]; | |
boutsum += sir[2]; | |
rinsum -= sir[0]; | |
ginsum -= sir[1]; | |
binsum -= sir[2]; | |
yi += w; | |
} | |
} | |
bitmap.setPixels(pix, 0, w, 0, 0, w, h); | |
return (bitmap); | |
} | |
//放大缩小图片 | |
public static Bitmap zoomBitmap(Bitmap bitmap,int w,int h){ | |
int width = bitmap.getWidth(); | |
int height = bitmap.getHeight(); | |
Matrix matrix = new Matrix(); | |
float scaleWidht = ((float)w / width); | |
float scaleHeight = ((float)h / height); | |
matrix.postScale(scaleWidht, scaleHeight); | |
Bitmap newbmp = Bitmap.createBitmap(bitmap, 0, 0, width, height, matrix, true); | |
return newbmp; | |
} | |
//将Drawable转化为Bitmap | |
public static Bitmap drawableToBitmap(Drawable drawable){ | |
int width = drawable.getIntrinsicWidth(); | |
int height = drawable.getIntrinsicHeight(); | |
Bitmap bitmap = Bitmap.createBitmap(width, height, | |
drawable.getOpacity() != PixelFormat.OPAQUE ? Bitmap.Config.ARGB_8888 | |
: Bitmap.Config.RGB_565); | |
Canvas canvas = new Canvas(bitmap); | |
drawable.setBounds(0,0,width,height); | |
drawable.draw(canvas); | |
return bitmap; | |
} | |
//获得圆角图片的方法 | |
public static Bitmap getRoundedCornerBitmap(Bitmap bitmap,float roundPx){ | |
Bitmap output = Bitmap.createBitmap(bitmap.getWidth(), bitmap | |
.getHeight(), 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); | |
paint.setAntiAlias(true); | |
canvas.drawARGB(0, 0, 0, 0); | |
paint.setColor(color); | |
canvas.drawRoundRect(rectF, roundPx, roundPx, paint); | |
paint.setXfermode(new PorterDuffXfermode(Mode.SRC_IN)); | |
canvas.drawBitmap(bitmap, rect, rect, paint); | |
return output; | |
} | |
//获得带倒影的图片方法 | |
public static Bitmap createReflectionImageWithOrigin(Bitmap bitmap){ | |
final int reflectionGap = 4; | |
int width = bitmap.getWidth(); | |
int height = bitmap.getHeight(); | |
Matrix matrix = new Matrix(); | |
matrix.preScale(1, -1); | |
Bitmap reflectionImage = Bitmap.createBitmap(bitmap, | |
0, height/2, width, height/2, matrix, false); | |
Bitmap bitmapWithReflection = Bitmap.createBitmap(width, (height + height/2), Config.ARGB_8888); | |
Canvas canvas = new Canvas(bitmapWithReflection); | |
canvas.drawBitmap(bitmap, 0, 0, null); | |
Paint deafalutPaint = new Paint(); | |
canvas.drawRect(0, height,width,height + reflectionGap, | |
deafalutPaint); | |
canvas.drawBitmap(reflectionImage, 0, height + reflectionGap, null); | |
Paint paint = new Paint(); | |
LinearGradient shader = new LinearGradient(0, | |
bitmap.getHeight(), 0, bitmapWithReflection.getHeight() | |
+ reflectionGap, 0x70ffffff, 0x00ffffff, TileMode.CLAMP); | |
paint.setShader(shader); | |
// Set the Transfer mode to be porter duff and destination in | |
paint.setXfermode(new PorterDuffXfermode(Mode.DST_IN)); | |
// Draw a rectangle using the paint with our linear gradient | |
canvas.drawRect(0, height, width, bitmapWithReflection.getHeight() | |
+ reflectionGap, paint); | |
return bitmapWithReflection; | |
} | |
} |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment