你想要的这都有-ImageView/Bitmap图片处理的工具类

ImageView/Bitmap图片处理的工具类

直接上工具类代码,可以直接用:

/**
* 对图片处理的工具类
*/
@SuppressLint("NewApi")
public class ImageUtil {
private WeakHashMap<Integer, WeakReference<Bitmap>> mBitmaps;
private WeakHashMap<Integer, WeakReference<Drawable>> mDrawables;
private Context mContext;
// 下载图片，最大边长
public static int MIN_SIDE_LENGTH = 256;
// 是否重新计算压缩比
public static boolean isComputeSampleSize = false;

private static final long POLY64REV = 0x95AC9329AC4BC9B5L;
private static final long INITIALCRC = 0xFFFFFFFFFFFFFFFFL;

private static long[] sCrcTable = new long[256];

public ImageUtil(Context context) {
mContext = context.getApplicationContext();
mBitmaps = new WeakHashMap<Integer, WeakReference<Bitmap>>();
mDrawables = new WeakHashMap<Integer, WeakReference<Drawable>>();
}

/**
* 根据drawable id获取Bitmap
*
* @param resource
* @return
*/
public Bitmap getBitmap(int resource) {
if (!mBitmaps.containsKey(resource) && mContext != null) {
mBitmaps.put(resource, new WeakReference<Bitmap>(
readDrawableBitmap(mContext, resource)));
}
return ((WeakReference<Bitmap>) mBitmaps.get(resource)).get();
}

/**
* 根据drawable id获取Drawable
*
* @param resource
* @return
*/
public Drawable getDrawable(int resource) {
try {
if (!mDrawables.containsKey(resource) && mContext != null) {
try {
mDrawables.put(resource, new WeakReference<Drawable>(mContext
.getResources().getDrawable(resource)));
} catch (OutOfMemoryError e) {
e.printStackTrace();
}
}
return ((WeakReference<Drawable>) mDrawables.get(resource)).get();
} catch (Exception e) {
e.printStackTrace();
}
return readBitmapResIdToDrawable(mContext, resource);
}

/**
*
* @param uri
* @param mcontext
* @return
*/
public static Drawable bitmapToDrawble(Uri uri,Context mcontext){
Drawable drawable = new BitmapDrawable(mcontext.getResources(), getBitmapFromUri(mcontext, uri));
return drawable;
}

@SuppressWarnings({ "unchecked", "rawtypes" })
public void recycleBitmaps() {
final Iterator itr = mBitmaps.entrySet().iterator();
while (itr.hasNext()) {
Map.Entry e = (Map.Entry) itr.next();
if (e != null) {
final Bitmap bitmap = ((WeakReference<Bitmap>) e.getValue()).get();
if (bitmap != null) {
bitmap.recycle();
}
}
}
mBitmaps.clear();
}

public static Drawable readBitmapResIdToDrawable(Context context, int resId) {
final BitmapFactory.Options opt = new BitmapFactory.Options();
opt.inPreferredConfig = Bitmap.Config.RGB_565;
opt.inPurgeable = true;
opt.inInputShareable = true;
// 获取资源图片
final InputStream is = context.getResources().openRawResource(resId);
final Bitmap btm = BitmapFactory.decodeStream(is, null, opt);
if (btm != null) {
final BitmapDrawable bd = new BitmapDrawable(btm);
try {
if (is != null) {
is.close();
}
} catch (IOException e) {
e.printStackTrace();
}
return bd;
}
return null;
}

/**
* 以最省内存的方式读取本地资源的图片
*
* @param context
* @param resId
* @return
*/
public static Bitmap readDrawableBitmap(Context context, int resId) {
final BitmapFactory.Options opt = new BitmapFactory.Options();
opt.inPreferredConfig = Bitmap.Config.RGB_565;
opt.inPurgeable = true;
opt.inInputShareable = true;
// 获取资源图片
final InputStream is = context.getResources().openRawResource(resId);
final Bitmap bitmap = BitmapFactory.decodeStream(is, null, opt);

try {
if (is != null) {
is.close();
}
} catch (IOException e) {
e.printStackTrace();
}
return bitmap;
}

public static Bitmap readBitmap565FromFile(String filename) {
Bitmap bitmap = null;
File file = new File(filename);
if (file.exists()) {
final BitmapFactory.Options options = new BitmapFactory.Options();
options.inPreferredConfig = Bitmap.Config.RGB_565;
options.inPurgeable = true;
options.inInputShareable = true;
try {
bitmap = BitmapFactory.decodeFile(filename, options);
if (bitmap == null) {
file.delete();
}
} catch (OutOfMemoryError e) {
e.printStackTrace();

if (bitmap != null && !bitmap.isRecycled()) {
bitmap.recycle();
bitmap = null;
}
System.gc();
}
}

return bitmap;
}

/**
* 读取本地drawable中较大的资源图片
*
* @param context
* @param resId
* @return
*/
public static Bitmap readDrawableBigBitmap(Context context, int resId) {
final InputStream is = context.getResources().openRawResource(resId);
// final BitmapFactory.Options options=new BitmapFactory.Options();
// options.inJustDecodeBounds = true;
// // 如果该
// 值设为true那么将不返回实际的bitmap，也不给其分配内存空间这样就避免内存溢出了。但是允许我们查询图片的信息这其中就包括图片大小信息（
// // options.outHeight (图片原始高度)和option.outWidth(图片原始宽度)）。
// BitmapFactory.decodeStream(is, null, options);
// options.inSampleSize = computeSampleSize(options, -1, 256*256);
// options.inJustDecodeBounds = false;
// return BitmapFactory.decodeStream(is, null, options);

final Bitmap bitmap = getBitmapFromStream(is, 256, 256);
try {
if (is != null) {
is.close();
}
} catch (IOException e) {
e.printStackTrace();
}
return bitmap;
}
//从文件得到BitMap
public static Bitmap getBitmapFromFile(String path, int width, int height) {
if (!TextUtils.isEmpty(path)) {
final File file = new File(path);
return getBitmapFromFile(file, width, height);
}
return null;
}
//从文件得到BitMap
public static Bitmap getBitmapFromFile(File dst, int width, int height) {
if (null != dst && dst.exists()) {
BitmapFactory.Options opts = null;
if (width > 0 && height > 0) {
opts = new BitmapFactory.Options();
opts.inJustDecodeBounds = true;
BitmapFactory.decodeFile(dst.getPath(), opts);
// 计算图片缩放比例
final int minSideLength = Math.min(width, height);
opts.inSampleSize = computeSampleSize(opts, minSideLength,
width * height);
opts.inPreferredConfig = Bitmap.Config.RGB_565;
opts.inJustDecodeBounds = false;
opts.inInputShareable = true;
opts.inPurgeable = true;
}
try {
return BitmapFactory.decodeFile(dst.getPath(), opts);
} catch (OutOfMemoryError e) {
e.printStackTrace();
System.gc();
}
}
return null;
}

public static Bitmap getBitmapByteArray(byte[] data, int width, int height) {
BitmapFactory.Options opts = null;
if (width > 0 && height > 0) {
opts = new BitmapFactory.Options();
opts.inJustDecodeBounds = true;
BitmapFactory.decodeByteArray(data, 0, data.length, opts);
// 计算图片缩放比例
final int minSideLength = Math.min(width, height);
opts.inSampleSize = computeSampleSize(opts, minSideLength, width
* height);
opts.inJustDecodeBounds = false;
opts.inInputShareable = true;
// 使得内存可以被回收
opts.inPurgeable = true;
opts.inPreferredConfig = Bitmap.Config.RGB_565;
}

try {
return BitmapFactory.decodeByteArray(data, 0, data.length, opts);
} catch (OutOfMemoryError e) {
e.printStackTrace();
System.gc();
}
return null;
}

public static Bitmap getBitmapFromStream(InputStream is, int width,
int height) {
BitmapFactory.Options opts = null;
if (width > 0 && height > 0) {
opts = new BitmapFactory.Options();
opts.inJustDecodeBounds = true;
BitmapFactory.decodeStream(is, null, opts);
// 计算图片缩放比例
final int minSideLength = Math.min(width, height);
opts.inSampleSize = computeSampleSize(opts, minSideLength, width
* height);
opts.inJustDecodeBounds = false;
opts.inInputShareable = true;
// 使得内存可以被回收
opts.inPurgeable = true;
opts.inPreferredConfig = Bitmap.Config.RGB_565;
}

try {
return BitmapFactory.decodeStream(is, null, opts);
} catch (OutOfMemoryError e) {
e.printStackTrace();
System.gc();
}
return null;
}



private static int computeInitialSampleSize(BitmapFactory.Options options,
int minSideLength, int maxNumOfPixels) {

final double w = options.outWidth;
final double h = options.outHeight;

final int lowerBound = (maxNumOfPixels == -1) ? 1 : (int) Math.ceil(Math
.sqrt(w * h / maxNumOfPixels));

final int upperBound = (minSideLength == -1) ? 128 : (int) Math.min(
Math.floor(w / minSideLength), Math.floor(h / minSideLength));

if (upperBound < lowerBound) {
// return the larger one when there is no overlapping zone.
return lowerBound;
}

if ((maxNumOfPixels == -1) && (minSideLength == -1)) {
return 1;
} else if (minSideLength == -1) {
return lowerBound;
} else {
return upperBound;
}
}

/**
* 图片透明度处理
*
* @param sourceImg
* 原始图片
* @param number
* 透明度
* @return
*/
public static Bitmap setAlpha(Bitmap sourceImg, int number) {
try {
int[] argb = new int[sourceImg.getWidth() * sourceImg.getHeight()];
sourceImg.getPixels(argb, 0, sourceImg.getWidth(), 0, 0,
sourceImg.getWidth(), sourceImg.getHeight());// 获得图片的ARGB值
number = number * 255 / 100;
for (int i = 0; i < argb.length; i++) {
if ((argb[i] & 0xff000000) != 0x00000000) {// 透明色不做处理
argb[i] = (number << 24) | (argb[i] & 0xFFFFFF);// 修改最高2位的值
}
}
sourceImg = Bitmap.createBitmap(argb, sourceImg.getWidth(),
sourceImg.getHeight(), Config.ARGB_8888);
} catch (OutOfMemoryError e) {
e.printStackTrace();
System.gc();
}
return sourceImg;
}

public static Bitmap drawableToBitmap(Drawable drawable) {

Bitmap bitmap = null;
try {
bitmap = Bitmap
.createBitmap(
drawable.getIntrinsicWidth(),
drawable.getIntrinsicHeight(),
drawable.getOpacity() != PixelFormat.OPAQUE ? Bitmap.Config.ARGB_8888
: Bitmap.Config.RGB_565);
final Canvas canvas = new Canvas(bitmap);
// canvas.setBitmap(bitmap);
drawable.setBounds(0, 0, drawable.getIntrinsicWidth(),
drawable.getIntrinsicHeight());
drawable.draw(canvas);
} catch (OutOfMemoryError e) {
e.printStackTrace();
if (bitmap != null && !bitmap.isRecycled()) {
bitmap.recycle();
bitmap = null;
}
System.gc();
}

return bitmap;
}

/**
* 获取源图片的BITMAP，压缩，本地图片
*
* @param sImagePath
* @return
*/
public static Bitmap getImgCacheFromLocal2Bitmap(String sImagePath) {
if (!TextUtils.isEmpty(sImagePath)) {
Bitmap bitmap = null;
try {
final File f = new File(sImagePath);
if (!f.exists()) {
return null;
}
final FileInputStream fis = new FileInputStream(f);
// bitmap = BitmapFactory.decodeStream(fis);
final BitmapFactory.Options options = new BitmapFactory.Options();
options.inJustDecodeBounds = false;
options.inSampleSize = 1; // width，hight设为原来的十分一
options.inPreferredConfig = Bitmap.Config.RGB_565;
options.inPurgeable = true;
options.inInputShareable = true;
bitmap = BitmapFactory.decodeStream(fis, null, options);
fis.close();
return bitmap;
} catch (Exception ex) {
ex.printStackTrace();
if (bitmap != null && !bitmap.isRecycled()) {
bitmap.recycle();
bitmap = null;
}
System.gc();
return null;
} catch (OutOfMemoryError ex) {
ex.printStackTrace();
if (bitmap != null && !bitmap.isRecycled()) {
bitmap.recycle();
bitmap = null;
}
System.gc();
return null;
}
}
return null;
}

public static byte[] getImgCacheFromLocal2Byte(String sImagePath) {
if (!TextUtils.isEmpty(sImagePath)) {
try {
final File f = new File(sImagePath);
if (!f.exists()) {
return null;
}
final FileInputStream fis = new FileInputStream(f);
final int length = fis.available();
final byte[] buffer = new byte[length];
fis.read(buffer);
fis.close();
return buffer;
} catch (Exception ex) {
ex.printStackTrace();
System.gc();
return null;
}
}
return null;
}

/**
* bitmap转byte[]
*
* @param bitmap
* @return
*/
public static byte[] getBitmap2Byte(Bitmap bitmap) {
if (bitmap != null) {
final ByteArrayOutputStream baos = new ByteArrayOutputStream();
bitmap.compress(Bitmap.CompressFormat.PNG, 100, baos);
final byte[] data = baos.toByteArray();
try {
baos.close();
} catch (IOException e) {
e.printStackTrace();
}
return data;
}
return null;
}

/**
* 获取缩略图
*
* @param bitmap
* @param isThumbnail
* 是否转成缩略图
* @return
*/
public static Bitmap decodeBitmapToThumbnail(Bitmap bitmap) {
return decodeBitmapToThumbnail(bitmap, true);
}

public static Bitmap decodeBitmapToThumbnail(Bitmap bitmap,
boolean isThumbnail) {
if (isThumbnail) {
final BitmapFactory.Options options = new BitmapFactory.Options();
options.inJustDecodeBounds = true;

final float realWidth = options.outWidth;
final float realHeight = options.outHeight;

// 计算缩放比
int scale = (int) ((realHeight > realWidth ? realHeight : realWidth) / 100);
if (scale <= 0) {
scale = 1;
}
options.inSampleSize = scale;
options.inJustDecodeBounds = false;
// 注意这次要把options.inJustDecodeBounds 设为 false,这次图片是要读取出来的。
final byte[] data = ImageUtil.getBitmap2Byte(bitmap);
if (data != null) {
bitmap = BitmapFactory.decodeByteArray(data, 0, data.length,
options);
}

}
return bitmap;
}

/**
* 保存图片
*
* @param sOldImagePath
* @param sNewImagePath
* @return
*/
public static boolean saveImage(Bitmap oldbitmap, String sNewImagePath) {

try {
final FileOutputStream fileout = new FileOutputStream(sNewImagePath);
oldbitmap.compress(CompressFormat.JPEG, 80, fileout);
fileout.flush();
fileout.close();
return true;
} catch (Exception e) {
e.printStackTrace();
System.gc();
return false;
}
}

public static boolean saveImage(byte[] oldbitmap, String sNewImagePath) {
try {
File file = new File(sNewImagePath);
if (file != null && !file.exists()) {
file.createNewFile();
}
final FileOutputStream fileout = new FileOutputStream(sNewImagePath);
fileout.write(oldbitmap);
fileout.flush();
fileout.close();
return true;
} catch (Exception e) {
e.printStackTrace();
System.gc();
return false;
}
}

public static Bitmap bytes2Bimap(byte[] b) {
if (b != null && b.length != 0) {
Bitmap bitmap = null;
try {
bitmap = BitmapFactory.decodeByteArray(b, 0, b.length);
} catch (OutOfMemoryError e) {
e.printStackTrace();
}
return bitmap;
} else {
return null;
}
}

/**
* 光晕效果
*
* @param bmp
* @param x
* 光晕中心点在bmp中的x坐标
* @param y
* 光晕中心点在bmp中的y坐标
* @param r
* 光晕的半径
* @return
*/
public static Bitmap grayMasking(Bitmap bmp, int x, int y, float r) {
// 高斯矩阵
int[] gauss = new int[] { 1, 2, 1, 2, 4, 2, 1, 2, 1 };

int width = bmp.getWidth();
int height = bmp.getHeight();
Bitmap bitmap = Bitmap.createBitmap(width, height,
Bitmap.Config.RGB_565);

int pixR = 0;
int pixG = 0;
int pixB = 0;

int pixColor = 0;

int newR = 0;
int newG = 0;
int newB = 0;

int delta = 18; // 值越小图片会越亮，越大则越暗

int idx = 0;
int[] pixels = new int[width * height];
bmp.getPixels(pixels, 0, width, 0, 0, width, height);
for (int i = 1, length = height - 1; i < length; i++) {
for (int k = 1, len = width - 1; k < len; k++) {
idx = 0;
int distance = (int) (Math.pow(k - x, 2) + Math.pow(i - y, 2));
// 不是中心区域的点做模糊处理
if (distance > r * r) {
for (int m = -1; m <= 1; m++) {
for (int n = -1; n <= 1; n++) {
pixColor = pixels[(i + m) * width + k + n];
pixR = Color.red(pixColor);
pixG = Color.green(pixColor);
pixB = Color.blue(pixColor);

newR = newR + (int) (pixR * gauss[idx]);
newG = newG + (int) (pixG * gauss[idx]);
newB = newB + (int) (pixB * gauss[idx]);
idx++;
}
}

newR /= delta;
newG /= delta;
newB /= delta;

newR = Math.min(255, Math.max(0, newR));
newG = Math.min(255, Math.max(0, newG));
newB = Math.min(255, Math.max(0, newB));

pixels[i * width + k] = Color.argb(255, newR, newG, newB);

newR = 0;
newG = 0;
newB = 0;
}
}
}

bitmap.setPixels(pixels, 0, width, 0, 0, width, height);
return bitmap;
}

/**
* 获取bitmap的字节大小
* @param bitmap
* @return
*/
public static int getBitmapSize(Bitmap bitmap) {

// if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT){ //API 19
// return bitmap.getAllocationByteCount();
// }
//
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB_MR1){//API 12
return bitmap.getByteCount();
}
return bitmap.getRowBytes() * bitmap.getHeight(); //earlier version
}

public static byte[] getBytes(String in) {
byte[] result = new byte[in.length() * 2];
int output = 0;
for (char ch : in.toCharArray()) {
result[output++] = (byte) (ch & 0xFF);
result[output++] = (byte) (ch >> 8);
}
return result;
}

public static boolean isSameKey(byte[] key, byte[] buffer) {
int n = key.length;
if (buffer.length < n) {
return false;
}
for (int i = 0; i < n; ++i) {
if (key[i] != buffer[i]) {
return false;
}
}
return true;
}

public static byte[] copyOfRange(byte[] original, int from, int to) {
int newLength = to - from;
if (newLength < 0)
throw new IllegalArgumentException(from + " > " + to);
byte[] copy = new byte[newLength];
System.arraycopy(original, from, copy, 0,Math.min(original.length - from, newLength));
return copy;
}



static {
//参考 http://bioinf.cs.ucl.ac.uk/downloads/crc64/crc64.c
long part;
for (int i = 0; i < 256; i++) {
part = i;
for (int j = 0; j < 8; j++) {
long x = ((int) part & 1) != 0 ? POLY64REV : 0;
part = (part >> 1) ^ x;
}
sCrcTable[i] = part;
}
}

public static byte[] makeKey(String httpUrl) {
return getBytes(httpUrl);
}

/**
* A function thats returns a 64-bit crc for string
*
* @param in input string
* @return a 64-bit crc value
*/
public static final long crc64Long(String in) {
if (in == null || in.length() == 0) {
return 0;
}
return crc64Long(getBytes(in));
}

public static final long crc64Long(byte[] buffer) {
long crc = INITIALCRC;
for (int k = 0, n = buffer.length; k < n; ++k) {
crc = sCrcTable[(((int) crc) ^ buffer[k]) & 0xff] ^ (crc >> 8);
}
return crc;
}

/**
* 将彩色图转换为黑白图
*
* @return 返回转换好的位图
*/
public static Bitmap convertToBlackWhite(Bitmap bmp) {
int width = bmp.getWidth(); // 获取位图的宽
int height = bmp.getHeight(); // 获取位图的高

int[] pixels = new int[width * height]; // 通过位图的大小创建像素点数组

bmp.getPixels(pixels, 0, width, 0, 0, width, height);
int alpha = 0xFF << 24;
for (int i = 0; i < height; i++) {
for (int j = 0; j < width; j++) {
int grey = pixels[width * i + j];

int red = ((grey & 0x00FF0000) >> 16);
int green = ((grey & 0x0000FF00) >> 8);
int blue = (grey & 0x000000FF);

grey = (int) (red * 0.3 + green * 0.59 + blue * 0.11);
grey = alpha | (grey << 16) | (grey << 8) | grey;
pixels[width * i + j] = grey;
}
}
Bitmap newBmp = Bitmap.createBitmap(width, height, Config.RGB_565);
newBmp.setPixels(pixels, 0, width, 0, 0, width, height);
return newBmp;
}

/**
* 转换成圆角
*
* @param bmp
* @param roundPx
* @return
*/
public static Bitmap convertToRoundedCorner(Bitmap bmp, float roundPx) {
Bitmap newBmp = Bitmap.createBitmap(bmp.getWidth(), bmp.getHeight(),
Config.ARGB_8888);
// 得到画布
Canvas canvas = new Canvas(newBmp);

final int color = 0xff424242;
final Paint paint = new Paint();
final Rect rect = new Rect(0, 0, bmp.getWidth(), bmp.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(bmp, rect, rect, paint);

return newBmp;
}

/** 水平方向模糊度 */
private static float hRadius = 2;
/** 竖直方向模糊度 */
private static float vRadius = 2;
/** 模糊迭代度 */
private static int iterations = 7;
/**
* 高斯模糊
*/
public static Bitmap BoxBlurFilter(Bitmap bmp) {
long start = System.currentTimeMillis();

int width = bmp.getWidth();
int height = bmp.getHeight();
int[] inPixels = new int[width * height];
int[] outPixels = new int[width * height];
Bitmap bitmap = Bitmap.createBitmap(width, height,Bitmap.Config.ARGB_8888);
bmp.getPixels(inPixels, 0, width, 0, 0, width, height);
for (int i = 0; i < iterations; i++) {
blur(inPixels, outPixels, width, height, hRadius);
blur(outPixels, inPixels, height, width, vRadius);
}
blurFractional(inPixels, outPixels, width, height, hRadius);
blurFractional(outPixels, inPixels, height, width, vRadius);
bitmap.setPixels(inPixels, 0, width, 0, 0, width, height);

long end = System.currentTimeMillis();

return bitmap;
}

public static void blur(int[] in, int[] out, int width, int height,
float radius) {
int widthMinus1 = width - 1;
int r = (int) radius;
int tableSize = 2 * r + 1;
int divide[] = new int[256 * tableSize];

for (int i = 0; i < 256 * tableSize; i++)
divide[i] = i / tableSize;

int inIndex = 0;

for (int y = 0; y < height; y++) {
int outIndex = y;
int ta = 0, tr = 0, tg = 0, tb = 0;

for (int i = -r; i <= r; i++) {
int rgb = in[inIndex + clamp(i, 0, width - 1)];
ta += (rgb >> 24) & 0xff;
tr += (rgb >> 16) & 0xff;
tg += (rgb >> 8) & 0xff;
tb += rgb & 0xff;
}

for (int x = 0; x < width; x++) {
out[outIndex] = (divide[ta] << 24) | (divide[tr] << 16)
| (divide[tg] << 8) | divide[tb];

int i1 = x + r + 1;
if (i1 > widthMinus1)
i1 = widthMinus1;
int i2 = x - r;
if (i2 < 0)
i2 = 0;
int rgb1 = in[inIndex + i1];
int rgb2 = in[inIndex + i2];

ta += ((rgb1 >> 24) & 0xff) - ((rgb2 >> 24) & 0xff);
tr += ((rgb1 & 0xff0000) - (rgb2 & 0xff0000)) >> 16;
tg += ((rgb1 & 0xff00) - (rgb2 & 0xff00)) >> 8;
tb += (rgb1 & 0xff) - (rgb2 & 0xff);
outIndex += height;
}
inIndex += width;
}
}

private static void blurFractional(int[] in, int[] out, int width,
int height, float radius) {
radius -= (int) radius;
float f = 1.0f / (1 + 2 * radius);
int inIndex = 0;

for (int y = 0; y < height; y++) {
int outIndex = y;

out[outIndex] = in[0];
outIndex += height;
for (int x = 1; x < width - 1; x++) {
int i = inIndex + x;
int rgb1 = in[i - 1];
int rgb2 = in[i];
int rgb3 = in[i + 1];

int a1 = (rgb1 >> 24) & 0xff;
int r1 = (rgb1 >> 16) & 0xff;
int g1 = (rgb1 >> 8) & 0xff;
int b1 = rgb1 & 0xff;
int a2 = (rgb2 >> 24) & 0xff;
int r2 = (rgb2 >> 16) & 0xff;
int g2 = (rgb2 >> 8) & 0xff;
int b2 = rgb2 & 0xff;
int a3 = (rgb3 >> 24) & 0xff;
int r3 = (rgb3 >> 16) & 0xff;
int g3 = (rgb3 >> 8) & 0xff;
int b3 = rgb3 & 0xff;
a1 = a2 + (int) ((a1 + a3) * radius);
r1 = r2 + (int) ((r1 + r3) * radius);
g1 = g2 + (int) ((g1 + g3) * radius);
b1 = b2 + (int) ((b1 + b3) * radius);
a1 *= f;
r1 *= f;
g1 *= f;
b1 *= f;
out[outIndex] = (a1 << 24) | (r1 << 16) | (g1 << 8) | b1;
outIndex += height;
}
out[outIndex] = in[width - 1];
inIndex += width;
}
}

public static int clamp(int x, int a, int b) {
return (x < a) ? a : (x > b) ? b : x;
}

/**
* 圆形图片
*
* @param bitmap
* @return
*/
public static Bitmap getCircleBitmap(Bitmap bitmap){
int width = bitmap.getWidth();
int height = bitmap.getHeight();
float roundPx;
float left, top, right, bottom, dst_left, dst_top, dst_right, dst_bottom;
if (width <= height) {
roundPx = width / 2;
top = 0;
bottom = width;
left = 0;
right = width;
height = width;
dst_left = 0;
dst_top = 0;
dst_right = width;
dst_bottom = width;
} else {
roundPx = height / 2;
float clip = (width - height) / 2;
left = clip;
right = width - clip;
top = 0;
bottom = height;
width = height;
dst_left = 0;
dst_top = 0;
dst_right = height;
dst_bottom = height;
}

Bitmap output = Bitmap.createBitmap(width, height, Config.ARGB_8888);
Canvas canvas = new Canvas(output);

final int color = 0xff424242;
final Paint paint = new Paint();
final Rect src = new Rect((int) left, (int) top, (int) right,
(int) bottom);
final Rect dst = new Rect((int) dst_left, (int) dst_top,
(int) dst_right, (int) dst_bottom);
final RectF rectF = new RectF(dst);

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, src, dst, paint);
return output;
}

/**
* 获取圆角
*
* @param bitmap
* @param pixels 角度
* @return
*/
public static Bitmap getRoundedCornerBitmap(Bitmap bitmap, int pixels) {
if (bitmap != null) {
final Bitmap output = Bitmap.createBitmap(bitmap.getWidth(),
bitmap.getHeight(), Config.ARGB_8888);
if (output != null) {
final 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(Mode.SRC_IN));
canvas.drawBitmap(bitmap, rect, rect, paint);
return output;
}
}

return null;
}

/**
*
* 从Assets中读取图片
* @param String filepath 相对路径
* @return Bitmap
*/
public static Bitmap getImageFromAssetsFile(String filepath, Context context) {
Bitmap image = null;
InputStream is = null;
AssetManager am = context.getResources().getAssets();
try {
is = am.open(filepath);
image = BitmapFactory.decodeStream(is);
is.close();
} catch (IOException e) {
e.printStackTrace();
} finally {
if (is != null)
try {
is.close();
} catch (IOException e) {
e.printStackTrace();
}
}

return image;
}

public static InputStream getImageFromAssetsFileInputStream(String filepath, Context context) {
InputStream is = null;
AssetManager am = context.getResources().getAssets();
try {
is = am.open(filepath);
} catch (IOException e) {
e.printStackTrace();
}
return is;
}

/**
* 按比例缩小图片（单位像素） lessen the bitmap
*
* @param src
* bitmap
* @param destWidth
* the dest bitmap width
* @param destHeigth
* @return new bitmap if successful ,oherwise null
*/
public static Bitmap lessenBitmap(Context context, int resId, int destWidth, int destHeigth) {

final BitmapFactory.Options opt = new BitmapFactory.Options();
opt.inPreferredConfig = Bitmap.Config.RGB_565;
opt.inPurgeable = true;
opt.inInputShareable = true;
// 获取资源图片
final InputStream is = context.getResources().openRawResource(resId);
final Bitmap bitmap = BitmapFactory.decodeStream(is, null, opt);

try {
if (is != null) {
is.close();
}
} catch (IOException e) {
e.printStackTrace();
}

final int w = bitmap.getWidth();// 源文件的大小
final int h = bitmap.getHeight();
float scaleWidth = ((float) destWidth) / w;// 宽度缩小比例
float scaleHeight = ((float) destHeigth) / h;// 高度缩小比例
final Matrix m = new Matrix();// 矩阵
m.postScale(scaleWidth, scaleHeight);// 设置矩阵比例
final Bitmap resizedBitmap = Bitmap.createBitmap(bitmap, 0, 0, w, h, m, true);// 直接按照矩阵的比例把源文件画入进

if (!bitmap.isRecycled()) {
bitmap.recycle();
}

return resizedBitmap;
}

/**
* 判断图片旋转情况
*
* @param path
* @return
*/
public static int readPictureDegree(String path) {
int degree = 0;
try {
final ExifInterface exifInterface = new ExifInterface(path);
final int orientation =
exifInterface.getAttributeInt(ExifInterface.TAG_ORIENTATION,
ExifInterface.ORIENTATION_NORMAL);
switch (orientation) {
case ExifInterface.ORIENTATION_ROTATE_90:
degree = 90;
break;
case ExifInterface.ORIENTATION_ROTATE_180:
degree = 180;
break;
case ExifInterface.ORIENTATION_ROTATE_270:
degree = 270;
break;
}
} catch (IOException e) {
e.printStackTrace();
}
return degree;
}

/**
* 旋转图片
* @param path 图片路径
* @param bitmap 原图
* @return
*/
public static Bitmap rotaingImageView(String path, Bitmap bitmap) {
// 旋转图片 动作
Matrix matrix = new Matrix();
final int angle = readPictureDegree(path);
if (angle != 0) {
matrix.postRotate(angle);
}
// 创建新的图片
Bitmap resizedBitmap = Bitmap.createBitmap(bitmap, 0, 0, bitmap.getWidth(), bitmap.getHeight(), matrix, true);
return resizedBitmap;
}

/**
* 图片旋转
*
* @param bm
* 图片资源Bitmap
* @param curDegrees
* //当前旋转度数
*/
public static Bitmap rotateBitmap(Bitmap bm, float curDegrees) {
return rotateBitmap(bm, curDegrees, true);
}

public static Bitmap rotateBitmap(Bitmap bm, float curDegrees, boolean isRecycled) {
if (bm == null) {
return null;
}
final int bmpW = bm.getWidth();
final int bmpH = bm.getHeight();
// 注意这个Matirx是android.graphics底下的那个
final Matrix mt = new Matrix();
mt.reset();
mt.setRotate(curDegrees);
final Bitmap bitmap = Bitmap.createBitmap(bm, 0, 0, bmpW, bmpH, mt,
true);

if (isRecycled && !bm.isRecycled()) {
bm.recycle();
}
return bitmap;
}

/**
* 根据uri获取图片
* @param context
* @param uri
* @return
*/
public static Bitmap getBitmapFromUri(Context context, Uri uri) {
try {
// 读取uri所在的图片
final Bitmap bitmap = MediaStore.Images.Media.getBitmap(
context.getContentResolver(), uri);
return bitmap;
} catch (Exception e) {
e.getMessage();
return null;
}
}

/**
* 图片uri转path
* //
*
* @param uri
* @param activity
* @return
*/
public static String getPicPathFromUri(Uri uri, Activity activity) {
String value = uri.getPath();

try {
if (value.startsWith("/external")) {
String[] proj = {MediaStore.Images.Media.DATA};
Cursor cursor = activity.managedQuery(uri, proj, null, null, null);
// Cursor cursor = activity.getContentResolver().query(uri, proj, null, null, null);
if (cursor != null && cursor.getCount() > 0) {
int column_index = cursor.getColumnIndexOrThrow(MediaStore.Images.Media.DATA);
cursor.moveToFirst();
final String picUri = cursor.getString(column_index);
//4.0以上的版本会自动关闭 (4.0--14;; 4.0.3--15)
if(Integer.parseInt(Build.VERSION.SDK) < 14)
{
if (cursor != null) {
cursor.close();
}
}
return picUri;
}
}
} catch (Exception e) {
e.printStackTrace();
return "";
}
return value;
}

public static Bitmap getPathToBitmap(String filePath) {
Bitmap bm = BitmapFactory.decodeFile(filePath);

// 处理某些手机拍照角度旋转的问题
final int degree = readPictureDegree(filePath);
if (degree != 0) {// 旋转照片角度
bm = rotateBitmap(bm, degree);
}
return bm;
}

/**
* 根据路径获得突破并压缩返回bitmap用于显示
*
* @param imagesrc
* @return
*/
public static Bitmap getSmallBitmap(String filePath) {
final BitmapFactory.Options options = new BitmapFactory.Options();
options.inJustDecodeBounds = true;
BitmapFactory.decodeFile(filePath, options);

// Calculate inSampleSize
options.inSampleSize = calculateInSampleSize(options, 480, 800);

// Decode bitmap with inSampleSize set
options.inJustDecodeBounds = false;


Bitmap bm = BitmapFactory.decodeFile(filePath, options);

// 处理某些手机拍照角度旋转的问题
final int degree = readPictureDegree(filePath);
if (degree != 0) {// 旋转照片角度
bm = rotateBitmap(bm, degree);
}
return bm;
}

public static int calculateInSampleSize(BitmapFactory.Options options,
int reqWidth, int reqHeight) {
// Raw height and width of image
final int height = options.outHeight;
final int width = options.outWidth;
int inSampleSize = 1;

if (height > reqHeight || width > reqWidth) {

// Calculate ratios of height and width to requested height and
// width
final int heightRatio = Math.round((float) height
/ (float) reqHeight);
final int widthRatio = Math.round((float) width / (float) reqWidth);

// Choose the smallest ratio as inSampleSize value, this will
// guarantee
// a final image with both dimensions larger than or equal to the
// requested height and width.
inSampleSize = heightRatio < widthRatio ? heightRatio : widthRatio;
}

return inSampleSize;
}

/**
* 从文件中获取图片
*
* @param path
* @return
*/
public static byte[] decodeBitmap(String path) {
BitmapFactory.Options opts = new BitmapFactory.Options();
opts.inJustDecodeBounds = true;// 设置成了true,不占用内存，只获取bitmap宽高
BitmapFactory.decodeFile(path, opts);
opts.inSampleSize = computeSampleSize(opts, -1, 1024 * 800);
opts.inJustDecodeBounds = false;// 这里一定要将其设置回false，因为之前我们将其设置成了true
opts.inPurgeable = true;
opts.inInputShareable = true;
opts.inDither = false;
opts.inPurgeable = true;
opts.inTempStorage = new byte[16 * 1024];
FileInputStream is = null;
Bitmap bmp = null;
ByteArrayOutputStream baos = null;
try {
is = new FileInputStream(path);
bmp = BitmapFactory.decodeFileDescriptor(is.getFD(), null, opts);
double scale = getScaling(opts.outWidth * opts.outHeight,
1024 * 600);
Bitmap bmp2 = Bitmap.createScaledBitmap(bmp,
(int) (opts.outWidth * scale),
(int) (opts.outHeight * scale), true);
bmp.recycle();
baos = new ByteArrayOutputStream();
bmp2.compress(Bitmap.CompressFormat.JPEG, 100, baos);
bmp2.recycle();
return baos.toByteArray();
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
is.close();
baos.close();
} catch (IOException e) {
e.printStackTrace();
}
System.gc();
}
return null;
}

private static double getScaling(int src, int des) {
/**
* 48 目标尺寸÷原尺寸 sqrt开方，得出宽高百分比 49
*/
double scale = Math.sqrt((double) des / (double) src);
return scale;
}

/**
* 使用该算法，就可动态计算出图片的inSampleSize。
*
* @param options
* @param minSideLength
* 调整后图片最小的宽或高值
* @param maxNumOfPixels
* 最大分辨率
* @return
*/
private static int computeSampleSize(BitmapFactory.Options options,
int minSideLength, int maxNumOfPixels) {
final int initialSize = computeInitialSampleSize(options, minSideLength,
maxNumOfPixels);

int roundedSize;
if (initialSize <= 8) {
roundedSize = 1;
while (roundedSize < initialSize) {
roundedSize <<= 1;
}
} else {
roundedSize = (initialSize + 7) / 8 * 8;
}

return roundedSize;
}

/**
* 长度单位转换
* @param context
* @param unit
* @param value
* @return
*/
public static float applyDimension(Context context,int unit, float value){
DisplayMetrics metrics = context.getResources().getDisplayMetrics();
return TypedValue.applyDimension(unit, value, metrics);
}
}