整合的圖片壓縮工具類ImageTools
根據網上找的資料和本身用到的地方進行修改的圖片壓縮工具類，有什麼不對的地方請見諒，源碼以下：java
public final class ImageTools {
/**
* Transfer drawable to bitmap
*
* @param drawable
* @return
*/
public static Bitmap drawableToBitmap(Drawable drawable) {
int w = drawable.getIntrinsicWidth();
int h = drawable.getIntrinsicHeight();
Config config = drawable.getOpacity() != PixelFormat.OPAQUE ? Config.ARGB_8888 : Config.RGB_565;
Bitmap bitmap = Bitmap.createBitmap(w, h, config);
Canvas canvas = new Canvas(bitmap);
drawable.setBounds(0, 0, w, h);
drawable.draw(canvas);
return bitmap;
}
/**
* Bitmap to drawable
*
* @param bitmap
* @return
*/
public static Drawable bitmapToDrawable(Bitmap bitmap) {
return new BitmapDrawable(bitmap);
}
/**
* Input stream to bitmap
*
* @param inputStream
* @return
* @throws Exception
*/
public static Bitmap inputStreamToBitmap(InputStream inputStream)
throws Exception {
return BitmapFactory.decodeStream(inputStream);
}
/**
* Byte transfer to bitmap
*
* @param byteArray
* @return
*/
public static Bitmap byteToBitmap(byte[] byteArray) {
if (byteArray.length != 0) {
return BitmapFactory
.decodeByteArray(byteArray, 0, byteArray.length);
} else {
return null;
}
}
/**
* Byte transfer to drawable
*
* @param byteArray
* @return
*/
public static Drawable byteToDrawable(byte[] byteArray) {
ByteArrayInputStream ins = null;
if (byteArray != null) {
ins = new ByteArrayInputStream(byteArray);
}
return Drawable.createFromStream(ins, null);
}
/**
* Bitmap transfer to bytes
*
* @param bm
* @return
*/
public static byte[] bitmapToBytes(Bitmap bm) {
byte[] bytes = null;
if (bm != null) {
ByteArrayOutputStream baos = new ByteArrayOutputStream();
bm.compress(Bitmap.CompressFormat.PNG, 100, baos);
bytes = baos.toByteArray();
}
return bytes;
}
/**
* Drawable transfer to bytes
*
* @param drawable
* @return
*/
public static byte[] drawableToBytes(Drawable drawable) {
BitmapDrawable bitmapDrawable = (BitmapDrawable) drawable;
Bitmap bitmap = bitmapDrawable.getBitmap();
byte[] bytes = bitmapToBytes(bitmap);
;
return bytes;
}
/**
* Base64 to byte[]
*/
public static byte[] base64ToBytes(String base64) throws IOException {
byte[] bytes = Base64.decode(base64, 1);
return bytes;
}
// /**
// * Byte[] to base64
// */
// public static String bytesToBase64(byte[] bytes) {
// String base64 = Base64.encodeToString(bytes, Base64.NO_WRAP);
// return base64;
// }
/**
* Byte[] to base64
*/
public static String bytesToBase64(byte[] bytes) {
String base64 = Base64.encodeToString(bytes, 1);
return base64;
}
/**
* 將bitmap轉換成base64字符串
*
* @param bitmap
* @return base64 字符串
*/
public static String bitmaptoString(Bitmap bitmap, int bitmapQuality) {
// 將Bitmap轉換成字符串
String string = null;
ByteArrayOutputStream bStream = new ByteArrayOutputStream();
bitmap.compress(Bitmap.CompressFormat.PNG, bitmapQuality, bStream);
byte[] bytes = bStream.toByteArray();
string = Base64.encodeToString(bytes, Base64.DEFAULT);
return string;
}
/**
* 將base64轉換成bitmap圖片
*
* @param string base64字符串
* @return bitmap
*/
public static Bitmap stringtoBitmap(String string) {
// 將字符串轉換成Bitmap類型
Bitmap bitmap = null;
try {
byte[] bitmapArray;
bitmapArray = Base64.decode(string, Base64.DEFAULT);
bitmap = BitmapFactory.decodeByteArray(bitmapArray, 0,bitmapArray.length);
} catch (Exception e) {
e.printStackTrace();
}
return bitmap;
}
/**
* 質量壓縮方法
*
* @param image 將要被壓縮的圖片
* @return bitmap壓縮後的圖片
*/
public static Bitmap compressImage(Bitmap image) {
ByteArrayOutputStream baos = new ByteArrayOutputStream();
image.compress(Bitmap.CompressFormat.JPEG, 100, baos);
int options = 100;
while (baos.toByteArray().length / 1024 > 100) {
baos.reset();
image.compress(Bitmap.CompressFormat.JPEG, options, baos);
options -= 10;
}
ByteArrayInputStream isBm = new ByteArrayInputStream(baos.toByteArray());
Bitmap bitmap = BitmapFactory.decodeStream(isBm, null, null);
return bitmap;
}
/**
* 質量壓縮方法
*
* @param image 將要被壓縮的圖片
* @return baos 壓縮後圖片輸出流
*/
public static ByteArrayOutputStream compress(Bitmap image) {
ByteArrayOutputStream baos = new ByteArrayOutputStream();
image.compress(Bitmap.CompressFormat.JPEG, 100, baos);
int options = 100;
while (baos.toByteArray().length / 1024 > 300) {
baos.reset();
image.compress(Bitmap.CompressFormat.JPEG, options, baos);
options -= 10;
}
ByteArrayInputStream isBm = new ByteArrayInputStream(baos.toByteArray());
Bitmap bitmap = BitmapFactory.decodeStream(isBm, null, null);
return baos;
}
/**
* 根據bitmap壓縮圖片質量
*
* @param bitmap 未壓縮的bitmap
* @return 壓縮後的bitmap
*/
public static Bitmap cQuality(Bitmap bitmap) {
ByteArrayOutputStream bOut = new ByteArrayOutputStream();
int beginRate = 100;
//第一個參數 ：圖片格式 ，第二個參數： 圖片質量，100爲最高，0爲最差 ，第三個參數：保存壓縮後的數據的流
bitmap.compress(Bitmap.CompressFormat.JPEG, 100, bOut);
while (bOut.size() / 1024 > 100) { //若是壓縮後大於100Kb，則提升壓縮率，從新壓縮
beginRate -= 10;
bOut.reset();
bitmap.compress(Bitmap.CompressFormat.JPEG, beginRate, bOut);
}
ByteArrayInputStream bInt = new ByteArrayInputStream(bOut.toByteArray());
Bitmap newBitmap = BitmapFactory.decodeStream(bInt);
if (newBitmap != null) {
return newBitmap;
} else {
return bitmap;
}
}
public static void imageZoom(Bitmap bitmap) {
//圖片容許最大空間 單位：KB
double maxSize = 400.00;
//將bitmap放至數組中，意在bitmap的大小（與實際讀取的原文件要大）
ByteArrayOutputStream baos = new ByteArrayOutputStream();
bitmap.compress(Bitmap.CompressFormat.JPEG, 100, baos);
byte[] b = baos.toByteArray();
//將字節換成KB
double mid = b.length / 1024;
//判斷bitmap佔用空間是否大於容許最大空間 若是大於則壓縮 小於則不壓縮
if (mid > maxSize) {
//獲取bitmap大小 是容許最大大小的多少倍
double i = mid / maxSize;
//開始壓縮 此處用到平方根 將寬帶和高度壓縮掉對應的平方根倍 （1.保持刻度和高度和原bitmap比率一致，壓縮後也達到了最大大小佔用空間的大小）
// bitmap = zoomBitmap(bitmap, bitmap.getWidth() / Math.sqrt(i), bitmap.getHeight() / Math.sqrt(i));
}
}
/**
* 圖片按比例大小壓縮方法（根據路徑獲取圖片並壓縮）
*/
public static Bitmap getImage(String srcPath) {
BitmapFactory.Options newOpts = new BitmapFactory.Options();
newOpts.inJustDecodeBounds = true;
Bitmap bitmap = BitmapFactory.decodeFile(srcPath, newOpts);// 此時返回bm爲空
newOpts.inJustDecodeBounds = false;
int w = newOpts.outWidth;
int h = newOpts.outHeight;
// 如今主流手機比較可能是800*480分辨率，因此高和寬咱們設置爲
float hh = 800f;// 這裏設置高度爲800f
float ww = 480f;// 這裏設置寬度爲480f
// 縮放比。因爲是固定比例縮放，只用高或者寬其中一個數據進行計算便可
int be = 1;// be=1表示不縮放
if (w > h && w > ww) {// 若是寬度大的話根據寬度固定大小縮放
be = (int) (newOpts.outWidth / ww);
} else if (w < h && h > hh) {// 若是高度高的話根據寬度固定大小縮放
be = (int) (newOpts.outHeight / hh);
}
if (be <= 0)
be = 1;
newOpts.inSampleSize = be;// 設置縮放比例
// 從新讀入圖片，注意此時已經把options.inJustDecodeBounds 設回false了
bitmap = BitmapFactory.decodeFile(srcPath, newOpts);
return compressImage(bitmap);// 壓縮比如例大小後再進行質量壓縮
}
/**
* 圖片按比例大小壓縮方法（根據路徑獲取圖片並壓縮）
*/
public static ByteArrayOutputStream getByteStream(String srcPath,int angle) {
BitmapFactory.Options newOpts = new BitmapFactory.Options();
newOpts.inJustDecodeBounds = true;
Bitmap bitmap = BitmapFactory.decodeFile(srcPath, newOpts);// 此時返回bm爲空
newOpts.inJustDecodeBounds = false;
int w = newOpts.outWidth;
int h = newOpts.outHeight;
// 如今主流手機比較可能是800*480分辨率，因此高和寬咱們設置爲
float ww = 800f;// 這裏設置寬度爲800f
int be = (int) (w / ww);
if (be <= 0)
be = 1;
newOpts.inSampleSize = be;// 設置縮放比例
// 從新讀入圖片，注意此時已經把options.inJustDecodeBounds 設回false了
Bitmap map = rotaingImageView(angle,BitmapFactory.decodeFile(srcPath, newOpts));
bitmap = zoomBitmap(map, w / be, h / be);
return compress(bitmap);// 壓縮比如例大小後再進行質量壓縮
}
/**
* 圖片按比例大小壓縮方法（根據圖片壓縮）
*/
public static ByteArrayOutputStream getBitmap(Bitmap bitmap, int angle) {
int w = bitmap.getWidth();
int h = bitmap.getHeight();
// 如今主流手機比較可能是800*480分辨率，因此高和寬咱們設置爲
float ww = 800f;// 這裏設置寬度爲800f
// 縮放比。因爲是固定比例縮放，只用高或者寬其中一個數據進行計算便可
// int be = 1;// be=1表示不縮放
// if (w > h && w > ww) {// 若是寬度大的話根據寬度固定大小縮放
// be = (int) (w / ww);
// } else if (w < h && h > ww) {// 若是高度高的話根據寬度固定大小縮放
// be = (int) (h / ww);
// }
int be = (int) (w / ww);
if (be <= 0)
be = 1;
// newOpts.inSampleSize = be;// 設置縮放比例
// 從新讀入圖片，注意此時已經把options.inJustDecodeBounds 設回false了
// bitmap = BitmapFactory.decodeFile(srcPath, newOpts);
bitmap = rotaingImageView(angle, zoomBitmap(bitmap, w / be, h / be));
return compress(bitmap);// 壓縮比如例大小後再進行質量壓縮
}
/**
* 經過uri獲取圖片並進行壓縮
*/
public static ByteArrayOutputStream getBitmapFormUri(Activity ac, Uri uri, int angle) throws FileNotFoundException, IOException {
InputStream input = ac.getContentResolver().openInputStream(uri);
BitmapFactory.Options onlyBoundsOptions = new BitmapFactory.Options();
onlyBoundsOptions.inJustDecodeBounds = true;
onlyBoundsOptions.inDither = true;//optional
onlyBoundsOptions.inPreferredConfig = Bitmap.Config.ARGB_8888;//optional
BitmapFactory.decodeStream(input, null, onlyBoundsOptions);
int originalWidth = onlyBoundsOptions.outWidth;
int originalHeight = onlyBoundsOptions.outHeight;
if ((originalWidth == -1) || (originalHeight == -1))
return null;
//圖片分辨率以480x800爲標準
// float hh = 800f;//這裏設置高度爲800f
float ww = 800f;//這裏設置寬度爲480f
//縮放比。因爲是固定比例縮放，只用高或者寬其中一個數據進行計算便可
int be = 1;//be=1表示不縮放
if (originalWidth > originalHeight && originalWidth > ww) {//若是寬度大的話根據寬度固定大小縮放
be = (int) (originalWidth / ww);
} else if (originalWidth < originalHeight && originalHeight > ww) {//若是高度高的話根據寬度固定大小縮放
be = (int) (originalHeight / ww);
}
// int be = (int) (originalWidth / ww);
if (be <= 0)
be = 1;
//比例壓縮
BitmapFactory.Options bitmapOptions = new BitmapFactory.Options();
bitmapOptions.inSampleSize = be;//設置縮放比例
bitmapOptions.inDither = true;//optional
bitmapOptions.inPreferredConfig = Bitmap.Config.ARGB_8888;//optional
input = ac.getContentResolver().openInputStream(uri);
Bitmap bitmap = rotaingImageView(angle, BitmapFactory.decodeStream(input, null, bitmapOptions));
input.close();
return compress(bitmap);//再進行質量壓縮
}
/**
* 根據圖片uri獲取圖片旋轉角度
* @param context
* @param mImageCaptureUri 圖片uri路徑
* @return angle 旋轉角度
*/
public static int setImage(Context context, Uri mImageCaptureUri) {
// 無論是拍照仍是選擇圖片每張圖片都有在數據中存儲也存儲有對應旋轉角度orientation值
// 因此咱們在取出圖片是把角度值取出以便能正確的顯示圖片,沒有旋轉時的效果觀看
ContentResolver cr = context.getContentResolver();
Cursor cursor = cr.query(mImageCaptureUri, null, null, null, null);// 根據Uri從數據庫中找
int angle = 0;
if (cursor != null) {
cursor.moveToFirst();// 把遊標移動到首位，由於這裏的Uri是包含ID的因此是惟一的不須要循環找指向第一個就是了
String filePath = cursor.getString(cursor.getColumnIndex("_data"));// 獲取圖片路
String orientation = cursor.getString(cursor.getColumnIndex("orientation"));// 獲取旋轉的角度
cursor.close();
if (orientation != null && !"".equals(orientation)) {
angle = Integer.parseInt(orientation);
}
}
Logs.e("angle:::::::::::" + angle);
return angle;
}
/**
* 讀取圖片屬性：旋轉的角度
*
* @param path 圖片絕對路徑
* @return degree旋轉的角度
*/
public static int readPictureDegree(String path) {
int degree = 0;
try {
ExifInterface exifInterface = new ExifInterface(path);
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();
}
Logs.e("degree::::::::" + degree);
return degree;
}
/**
* 旋轉圖片
*
* @param angle 圖片旋轉角度
* @param bitmap 原圖片
* @return Bitmap旋轉後的圖片
*/
public static Bitmap rotaingImageView(int angle, Bitmap bitmap) {
//旋轉圖片 動做
Matrix matrix = new Matrix();
// matrix.postRotate(angle);
System.out.println("angle2=" + angle);
matrix.setRotate(angle); // 旋轉angle度
// 建立新的圖片
Bitmap resizedBitmap = Bitmap.createBitmap(bitmap, 0, 0, bitmap.getWidth(), bitmap.getHeight(), matrix, true);
return resizedBitmap;
}
/**
* Create reflection images
*
* @param bitmap
* @return
*/
public static Bitmap createReflectionImageWithOrigin(Bitmap bitmap) {
final int reflectionGap = 4;
int w = bitmap.getWidth();
int h = bitmap.getHeight();
Matrix matrix = new Matrix();
matrix.preScale(1, -1);
Bitmap reflectionImage = Bitmap.createBitmap(bitmap, 0, h / 2, w,
h / 2, matrix, false);
Bitmap bitmapWithReflection = Bitmap.createBitmap(w, (h + h / 2),
Config.ARGB_8888);
Canvas canvas = new Canvas(bitmapWithReflection);
canvas.drawBitmap(bitmap, 0, 0, null);
Paint deafalutPaint = new Paint();
canvas.drawRect(0, h, w, h + reflectionGap, deafalutPaint);
canvas.drawBitmap(reflectionImage, 0, h + 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, h, w, bitmapWithReflection.getHeight()
+ reflectionGap, paint);
return bitmapWithReflection;
}
/**
* Get rounded corner images
*
* @param bitmap
* @param roundPx 5 10
* @return
*/
public static Bitmap getRoundedCornerBitmap(Bitmap bitmap, float roundPx) {
int w = bitmap.getWidth();
int h = bitmap.getHeight();
Bitmap output = Bitmap.createBitmap(w, h, Config.ARGB_8888);
Canvas canvas = new Canvas(output);
final int color = 0xff424242;
final Paint paint = new Paint();
final Rect rect = new Rect(0, 0, w, h);
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;
}
/**
* Resize the bitmap
*
* @param bitmap
* @param width
* @param height
* @return
*/
public static Bitmap zoomBitmap(Bitmap bitmap, int width, int height) {
int w = bitmap.getWidth();
int h = bitmap.getHeight();
Matrix matrix = new Matrix();
float scaleWidth = ((float) width / w);
float scaleHeight = ((float) height / h);
matrix.postScale(scaleWidth, scaleHeight);
Bitmap newbmp = Bitmap.createBitmap(bitmap, 0, 0, w, h, matrix, true);
return newbmp;
}
/**
* Resize the drawable
*
* @param drawable
* @param w
* @param h
* @return
*/
public static Drawable zoomDrawable(Drawable drawable, int w, int h) {
int width = drawable.getIntrinsicWidth();
int height = drawable.getIntrinsicHeight();
Bitmap oldbmp = drawableToBitmap(drawable);
Matrix matrix = new Matrix();
float sx = ((float) w / width);
float sy = ((float) h / height);
matrix.postScale(sx, sy);
Bitmap newbmp = Bitmap.createBitmap(oldbmp, 0, 0, width, height,
matrix, true);
return new BitmapDrawable(newbmp);
}
/**
* Get images from SD card by path and the name of image
*
* @param photoName
* @return
*/
public static Bitmap getPhotoFromSDCard(String path, String photoName) {
Bitmap photoBitmap = BitmapFactory.decodeFile(path + "/" + photoName + ".png");
if (photoBitmap == null) {
return null;
} else {
return photoBitmap;
}
}
/**
* Check the SD card
*
* @return
*/
public static boolean checkSDCardAvailable() {
return android.os.Environment.getExternalStorageState().equals(android.os.Environment.MEDIA_MOUNTED);
}
/**
* Get image from SD card by path and the name of image
*
* @param photoName
* @return
*/
public static boolean findPhotoFromSDCard(String path, String photoName) {
boolean flag = false;
if (checkSDCardAvailable()) {
File dir = new File(path);
if (dir.exists()) {
File folders = new File(path);
File photoFile[] = folders.listFiles();
for (int i = 0; i < photoFile.length; i++) {
String fileName = photoFile[i].getName().split("\\.")[0];
if (fileName.equals(photoName)) {
flag = true;
}
}
} else {
flag = false;
}
// File file = new File(path + "/" + photoName + ".jpg" );
// if (file.exists()) {
// flag = true;
// }else {
// flag = false;
// }
} else {
flag = false;
}
return flag;
}
/**
* Save image to the SD card
*
* @param photoBitmap
* @param photoName
* @param path
*/
public static void savePhotoToSDCard(Bitmap photoBitmap, String path, String photoName) {
if (checkSDCardAvailable()) {
File dir = new File(path);
if (!dir.exists()) {
dir.mkdirs();
}
File photoFile = new File(path, photoName + ".png");
FileOutputStream fileOutputStream = null;
try {
fileOutputStream = new FileOutputStream(photoFile);
if (photoBitmap != null) {
if (photoBitmap.compress(Bitmap.CompressFormat.PNG, 100, fileOutputStream)) {
fileOutputStream.flush();
// fileOutputStream.close();
}
}
} catch (FileNotFoundException e) {
photoFile.delete();
e.printStackTrace();
} catch (IOException e) {
photoFile.delete();
e.printStackTrace();
} finally {
try {
fileOutputStream.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
/**
* Delete the image from SD card
*
* @param path file:///sdcard/temp.jpg
*/
public static void deleteAllPhoto(String path) {
if (checkSDCardAvailable()) {
File folder = new File(path);
File[] files = folder.listFiles();
for (int i = 0; i < files.length; i++) {
files[i].delete();
}
}
}
public static void deletePhotoAtPathAndName(String path, String fileName) {
if (checkSDCardAvailable()) {
File folder = new File(path);
File[] files = folder.listFiles();
for (int i = 0; i < files.length; i++) {
if (files[i].getName().split("\\.")[0].equals(fileName)) {
files[i].delete();
}
}
}
}
}
相關文章
- 1. 圖片壓縮工具類
- 2. 圖片壓縮java工具類
- 3. 圖片壓縮工具pngquant.rar
- 4. 圖片壓縮工具
- 5. JavaScript 圖片壓縮工具
- 6. 【PC工具】圖片壓縮哪家強!tinyPNG圖片壓縮工具
- 7. 圖片壓縮類
- 8. springboot整合thumbnailator實現圖片壓縮
- 9. 圖片壓縮工具推薦
- 10. JS脫機版：圖片壓縮工具
- 更多相關文章...
- • jQuery Mobile 工具欄 - jQuery Mobile 教程
- • Markdown 圖片 - Markdown 教程
- • PHP開發工具
- • 互聯網組織的未來：剖析GitHub員工的任性之源
相關標籤/搜索
每日一句
-
每一个你不满意的现在，都有一个你没有努力的曾经。
最新文章
- 1. Appium入門
- 2. Spring WebFlux 源碼分析(2)-Netty 服務器啓動服務流程 --TBD
- 3. wxpython入門第六步（高級組件）
- 4. CentOS7.5安裝SVN和可視化管理工具iF.SVNAdmin
- 5. jedis 3.0.1中JedisPoolConfig對象缺少setMaxIdle、setMaxWaitMillis等方法，問題記錄
- 6. 一步一圖一代碼，一定要讓你真正徹底明白紅黑樹
- 7. 2018-04-12—（重點）源碼角度分析Handler運行原理
- 8. Spring AOP源碼詳細解析
- 9. Spring Cloud（1）
- 10. python簡單爬去油價信息發送到公衆號
歡迎關注本站公眾號,獲取更多信息
相關文章
- 1. 圖片壓縮工具類
- 2. 圖片壓縮java工具類
- 3. 圖片壓縮工具pngquant.rar
- 4. 圖片壓縮工具
- 5. JavaScript 圖片壓縮工具
- 6. 【PC工具】圖片壓縮哪家強!tinyPNG圖片壓縮工具
- 7. 圖片壓縮類
- 8. springboot整合thumbnailator實現圖片壓縮
- 9. 圖片壓縮工具推薦
- 10. JS脫機版：圖片壓縮工具