package com.marshalchen.common.commonUtils.urlUtils;
import java.io.*;
import java.net.HttpURLConnection;
import java.net.MalformedURLException;
import java.net.URL;
import android.content.ContentResolver;
import android.content.Context;
import android.content.res.Resources;
import android.graphics.*;
import android.graphics.Bitmap.Config;
import android.graphics.PorterDuff.Mode;
import android.graphics.drawable.BitmapDrawable;
import android.graphics.drawable.Drawable;
import android.net.Uri;
import com.marshalchen.common.commonUtils.logUtils.Logs;
public class ImageUtils_Deprecated {
public static final int LEFT = 0;
public static final int RIGHT = 1;
public static final int TOP = 3;
public static final int BOTTOM = 4;
/**
* 图片去色,返回灰度图片
*
* @param bmpOriginal 传入的图片
* @return 去色后的图片
*/
public static Bitmap toGrayscale(Bitmap bmpOriginal) {
int width, height;
height = bmpOriginal.getHeight();
width = bmpOriginal.getWidth();
Bitmap bmpGrayscale = Bitmap.createBitmap(width, height, Config.RGB_565);
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;
}
/** */
/**
* 去色同时加圆角
*
* @param bmpOriginal 原图
* @param pixels 圆角弧度
* @return 修改后的图片
*/
public static Bitmap toGrayscale(Bitmap bmpOriginal, int pixels) {
return toRoundCorner(toGrayscale(bmpOriginal), pixels);
}
/** */
/**
* 把图片变成圆角
*
* @param bitmap 需要修改的图片
* @param pixels 圆角的弧度
* @return 圆角图片
*/
public static Bitmap toRoundCorner(Bitmap bitmap, int pixels) {
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);
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;
}
public static Bitmap toRoundCorner(Bitmap bitmap, float pixels) {
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);
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);
System.out.println("pixels+++++++" + pixels);
return output;
}
/** */
/**
* 使圆角功能支持BitampDrawable
*
* @param bitmapDrawable
* @param pixels
* @return
*/
public static BitmapDrawable toRoundCorner(BitmapDrawable bitmapDrawable, int pixels) {
Bitmap bitmap = bitmapDrawable.getBitmap();
bitmapDrawable = new BitmapDrawable(toRoundCorner(bitmap, pixels));
return bitmapDrawable;
}
/**
* 读取路径中的图片，然后将其转化为缩放后的bitmap
*
* @param path
*/
public static void saveBefore(String path) {
BitmapFactory.Options options = new BitmapFactory.Options();
options.inJustDecodeBounds = true;
// 获取这个图片的宽和高
Bitmap bitmap = BitmapFactory.decodeFile(path, options); // 此时返回bm为空
options.inJustDecodeBounds = false;
// 计算缩放比
int be = (int) (options.outHeight / (float) 200);
if (be <= 0)
be = 1;
options.inSampleSize = 2; // 图片长宽各缩小二分之一
// 重新读入图片，注意这次要把options.inJustDecodeBounds 设为 false哦
bitmap = BitmapFactory.decodeFile(path, options);
int w = bitmap.getWidth();
int h = bitmap.getHeight();
System.out.println(w + " " + h);
// savePNG_After(bitmap,path);
saveJPGE_After(bitmap, path);
}
/**
* 保存图片为PNG
*
* @param bitmap
* @param name
*/
public static void savePNG_After(Bitmap bitmap, String name) {
File file = new File(name);
try {
FileOutputStream out = new FileOutputStream(file);
if (bitmap.compress(Bitmap.CompressFormat.PNG, 100, out)) {
out.flush();
out.close();
}
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
/**
* 保存图片为JPEG
*
* @param bitmap
* @param path
*/
public static void saveJPGE_After(Bitmap bitmap, String path) {
File file = new File(path);
try {
FileOutputStream out = new FileOutputStream(file);
if (bitmap.compress(Bitmap.CompressFormat.JPEG, 100, out)) {
out.flush();
out.close();
}
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
/**
* 水印
*
* @param
* @return
*/
public static Bitmap createBitmapForWatermark(Bitmap src, Bitmap watermark) {
if (src == null) {
return null;
}
int w = src.getWidth();
int h = src.getHeight();
int ww = watermark.getWidth();
int wh = watermark.getHeight();
// create the new blank bitmap
Bitmap newb = Bitmap.createBitmap(w, h, Config.ARGB_8888);// 创建一个新的和SRC长度宽度一样的位图
Canvas cv = new Canvas(newb);
// draw src into
cv.drawBitmap(src, 0, 0, null);// 在 0，0坐标开始画入src
// draw watermark into
cv.drawBitmap(watermark, w - ww + 5, h - wh + 5, null);// 在src的右下角画入水印
// save all clip
cv.save(Canvas.ALL_SAVE_FLAG);// 保存
// store
cv.restore();// 存储
return newb;
}
/**
* 图片合成
*
* @return
*/
public static Bitmap potoMix(int direction, Bitmap... bitmaps) {
if (bitmaps.length <= 0) {
return null;
}
if (bitmaps.length == 1) {
return bitmaps[0];
}
Bitmap newBitmap = bitmaps[0];
// newBitmap = createBitmapForFotoMix(bitmaps[0],bitmaps[1],direction);
for (int i = 1; i < bitmaps.length; i++) {
newBitmap = createBitmapForFotoMix(newBitmap, bitmaps[i], direction);
}
return newBitmap;
}
private static Bitmap createBitmapForFotoMix(Bitmap first, Bitmap second, int direction) {
if (first == null) {
return null;
}
if (second == null) {
return first;
}
int fw = first.getWidth();
int fh = first.getHeight();
int sw = second.getWidth();
int sh = second.getHeight();
Bitmap newBitmap = null;
if (direction == LEFT) {
newBitmap = Bitmap.createBitmap(fw + sw, fh > sh ? fh : sh, Config.ARGB_8888);
Canvas canvas = new Canvas(newBitmap);
canvas.drawBitmap(first, sw, 0, null);
canvas.drawBitmap(second, 0, 0, null);
} else if (direction == RIGHT) {
newBitmap = Bitmap.createBitmap(fw + sw, fh > sh ? fh : sh, Config.ARGB_8888);
Canvas canvas = new Canvas(newBitmap);
canvas.drawBitmap(first, 0, 0, null);
canvas.drawBitmap(second, fw, 0, null);
} else if (direction == TOP) {
newBitmap = Bitmap.createBitmap(sw > fw ? sw : fw, fh + sh, Config.ARGB_8888);
Canvas canvas = new Canvas(newBitmap);
canvas.drawBitmap(first, 0, sh, null);
canvas.drawBitmap(second, 0, 0, null);
} else if (direction == BOTTOM) {
newBitmap = Bitmap.createBitmap(sw > fw ? sw : fw, fh + sh, Config.ARGB_8888);
Canvas canvas = new Canvas(newBitmap);
canvas.drawBitmap(first, 0, 0, null);
canvas.drawBitmap(second, 0, fh, null);
}
return newBitmap;
}
/**
* 将Bitmap转换成指定大小
*
* @param bitmap
* @param width
* @param height
* @return
*/
public static Bitmap createBitmapBySize(Bitmap bitmap, int width, int height) {
return Bitmap.createScaledBitmap(bitmap, width, height, true);
}
/**
* Drawable 转 Bitmap
*
* @param drawable
* @return
*/
public static Bitmap drawableToBitmapByBD(Drawable drawable) {
BitmapDrawable bitmapDrawable = (BitmapDrawable) drawable;
return bitmapDrawable.getBitmap();
}
/**
* Bitmap 转 Drawable
*
* @param bitmap
* @return
*/
public static Drawable bitmapToDrawableByBD(Bitmap bitmap) {
Drawable drawable = new BitmapDrawable(bitmap);
return drawable;
}
public static BitmapDrawable bitmapToBtDrawable(Resources res, Bitmap bitmap) {
BitmapDrawable drawable = new BitmapDrawable(res, bitmap);
return drawable;
}
/**
* byte[] 转 bitmap
*
* @param b
* @return
*/
public static Bitmap bytesToBimap(byte[] b) {
if (b.length != 0) {
return BitmapFactory.decodeByteArray(b, 0, b.length);
} else {
return null;
}
}
/**
* bitmap 转 byte[]
*
* @param bm
* @return
*/
public static byte[] bitmapToBytes(Bitmap bm) {
ByteArrayOutputStream baos = new ByteArrayOutputStream();
bm.compress(Bitmap.CompressFormat.PNG, 100, baos);
return baos.toByteArray();
}
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 scaleWidth = ((float) w / width);
float scaleHeight = ((float) h / height);
matrix.postScale(scaleWidth, scaleHeight);
// Bitmap.createBitmap()
Bitmap newbmp = Bitmap.createBitmap(oldbmp, 0, 0, width, height,
matrix, true);
return new BitmapDrawable(null, newbmp);
}
// 对分辨率较大的图片进行缩放
public static Bitmap zoomBitmap(Bitmap bitmap, float width, float 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;
}
public static void convert_to_small_img(String frompath, String topath,
Bitmap bitmap, int pix) throws IOException {
long size = new File(frompath).length();
BitmapFactory.Options options = new BitmapFactory.Options();
options.inSampleSize = (int) Math.sqrt(size / 100 / 1025.0);
File tofile = new File(topath);
BufferedOutputStream bos = new BufferedOutputStream(
new FileOutputStream(tofile));
bitmap = BitmapFactory.decodeFile(frompath, options);
bitmap.compress(Bitmap.CompressFormat.JPEG, pix, bos);
bos.close();
}
public static Bitmap drawableToBitmap(Drawable drawable) {
if (null == drawable) {
return null;
}
Bitmap bitmap = Bitmap
.createBitmap(
drawable.getIntrinsicWidth() / 2,
drawable.getIntrinsicHeight() / 2,
drawable.getOpacity() != PixelFormat.OPAQUE ? Config.ARGB_8888
: Config.RGB_565
);
Canvas canvas = new Canvas(bitmap);
drawable.setBounds(0, 0, drawable.getIntrinsicWidth() / 2, drawable.getIntrinsicHeight() / 2);
drawable.draw(canvas);
return bitmap;
}
public static Bitmap drawableToBitmapOriginal(Drawable drawable) {
if (null == drawable) {
return null;
}
Bitmap bitmap = Bitmap
.createBitmap(
drawable.getIntrinsicWidth(),
drawable.getIntrinsicHeight(),
drawable.getOpacity() != PixelFormat.OPAQUE ? Config.ARGB_8888
: Config.RGB_565
);
Canvas canvas = new Canvas(bitmap);
drawable.setBounds(0, 0, drawable.getIntrinsicWidth(), drawable.getIntrinsicHeight());
drawable.draw(canvas);
return bitmap;
}
public static Bitmap drawableToBitmapOriginals(Drawable drawable) {
if (null == drawable) {
return null;
}
BitmapDrawable bitDw = ((BitmapDrawable) drawable);
Bitmap bitmap = bitDw.getBitmap();
ByteArrayOutputStream stream = new ByteArrayOutputStream();
bitmap.compress(Bitmap.CompressFormat.JPEG, 100, stream);
byte[] imageInByte = stream.toByteArray();
System.out.println("........length......" + imageInByte);
ByteArrayInputStream bis = new ByteArrayInputStream(imageInByte);
return bitmap;
}
// 通过Drawable获得圆角图片
public static Bitmap getRoundedCornerBitmap(Drawable drawable) {
Bitmap bitmap = drawableToBitmap(drawable);
if (null == bitmap) {
return null;
}
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);
final float roundPx = 10;
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);
bitmap = null;
return output;
}
// 通过Drawable获得缩小圆角图片
public static Bitmap getRoundedCornerShadowBitmap(byte[] bytes) {
if (null != bytes) {
BitmapFactory.Options options = new BitmapFactory.Options();
options.inSampleSize = 2;// 图片宽高都为原来的二分之一，即图片为原来的四分之一
Bitmap bitmap = BitmapFactory.decodeByteArray(bytes, 0,
bytes.length, options);
Bitmap output = Bitmap.createBitmap(bitmap.getWidth(), bitmap
.getHeight(), Config.ARGB_8888);
Canvas canvas = new Canvas(output);
final Rect rect = new Rect(0, 0, bitmap.getWidth(), bitmap
.getHeight());
final RectF rectF = new RectF(rect);
final float roundPx = 5;
Paint paint = new Paint();
paint.setAntiAlias(true);
canvas.drawARGB(0, 0, 0, 0);
paint.setColor(Color.RED);
canvas.drawRoundRect(rectF, roundPx, roundPx, paint);
paint.setXfermode(new PorterDuffXfermode(Mode.SRC_IN));
canvas.drawBitmap(bitmap, rect, rect, paint);
bitmap.recycle();
bitmap = null;
return output;
} else {
return null;
}
}
public static byte[] Bitmap2Bytes(Bitmap bm) {
if (null != bm) {
ByteArrayOutputStream baos = new ByteArrayOutputStream();
bm.compress(Bitmap.CompressFormat.PNG, 100, baos);
return baos.toByteArray();
} else {
return null;
}
}
public static Bitmap Bytes2Bimap(byte[] b, int reqWidth, int reqHeight) {
if (null != b && b.length != 0) {
BitmapFactory.Options options = new BitmapFactory.Options();
options.inJustDecodeBounds = true;
Bitmap bmp = BitmapFactory.decodeByteArray(b, 0, b.length, options);
final int height = options.outHeight;
final int width = options.outWidth;
int inSampleSize = 1;
/*if (height > reqHeight || width > reqWidth) {
if (width > height) {
inSampleSize = Math.round((float)height / (float)reqHeight);
} else {
inSampleSize = Math.round((float)width / (float)reqWidth);
}
}*/
options.inSampleSize = inSampleSize;
options.inJustDecodeBounds = false;
bmp = BitmapFactory.decodeByteArray(b, 0, b.length, options);
b = null;
return bmp;
} else {
return null;
}
}
public static Bitmap Bytes2Bimap(byte[] b) {
if (null != b && b.length != 0) {
BitmapFactory.Options options = new BitmapFactory.Options();
options.inJustDecodeBounds = true;
Bitmap bmp = BitmapFactory.decodeByteArray(b, 0, b.length, options);
options.inSampleSize = 1;
options.inJustDecodeBounds = false;
bmp = BitmapFactory.decodeByteArray(b, 0, b.length, options);
b = null;
return bmp;
} else {
return null;
}
}
// 通过byte[]获得圆角图片
public static Bitmap getRoundedCornerBitmap(byte[] bytes) {
if (null != bytes) {
BitmapFactory.Options options = new BitmapFactory.Options();
options.inSampleSize = 1;// 图片宽高都为原来的二分之一，即图片为原来的四分之一
Bitmap bitmap = BitmapFactory.decodeByteArray(bytes, 0,
bytes.length, options);
if (null == bitmap) {
/* 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);
final float roundPx = 10;
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);
bitmap.recycle();
bitmap = null;
Log.i("ImageUtils", "" + bytes);
return utput;*/
return null;
} else {
return bitmap;
}
} else {
return null;
}
/**/
}
// 通过Bitmap获得圆角图片
public static Bitmap getRoundedCornerBitmap(Bitmap bitmap) {
if (null == bitmap) {
return bitmap;
}
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);
final float roundPx = 10;
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 returnBitMap(String url) {
URL myFileUrl = null;
Bitmap bitmap = null;
try {
myFileUrl = new URL(url);
} catch (MalformedURLException e) {
e.printStackTrace();
}
try {
HttpURLConnection conn = (HttpURLConnection) myFileUrl
.openConnection();
conn.setDoInput(true);
conn.connect();
InputStream is = conn.getInputStream();
bitmap = BitmapFactory.decodeStream(is);
is.close();
} catch (IOException e) {
e.printStackTrace();
}
return bitmap;
}
public static Bitmap getBitMap(String url) {
URL myFileUrl = null;
Bitmap bitmap = null;
try {
myFileUrl = new URL(url);
} catch (MalformedURLException e) {
e.printStackTrace();
}
try {
HttpURLConnection conn = (HttpURLConnection) myFileUrl
.openConnection();
conn.setRequestProperty("referer", "http://t.qingdaonews.com");
conn.setDoInput(true);
conn.connect();
InputStream is = conn.getInputStream();
bitmap = BitmapFactory.decodeStream(is);
is.close();
conn.disconnect();
} catch (IOException e) {
e.printStackTrace();
}
return bitmap;
}
public static Drawable drawableFromUrl(Context context, String url) throws IOException {
Bitmap x;
HttpURLConnection connection = (HttpURLConnection) new URL(url).openConnection();
connection.connect();
InputStream input = connection.getInputStream();
x = BitmapFactory.decodeStream(input);
return new BitmapDrawable(context.getResources(), x);
}
public static Bitmap getBitmapFromSdCard(String path) {
Bitmap bitmap = null;
try {
File file = new File(path);
if (file.exists()) {
bitmap = BitmapFactory.decodeFile(path);
}
} catch (Exception e) {
e.printStackTrace();
Logs.e(e, "");
}
return bitmap;
}
public static Bitmap getSmallBitmapFromFile(File file) {
try {
// File f = new File(path);
File f = file;
//Decode image size
BitmapFactory.Options o = new BitmapFactory.Options();
o.inJustDecodeBounds = true;
BitmapFactory.decodeStream(new FileInputStream(f), null, o);
//The new size we want to scale to
final int REQUIRED_SIZE = 280;
//Find the correct scale value. It should be the power of 2.
int scale = 1;
while (o.outWidth / scale / 2 >= REQUIRED_SIZE && o.outHeight / scale / 2 >= REQUIRED_SIZE)
scale *= 2;
//Decode with inSampleSize
BitmapFactory.Options o2 = new BitmapFactory.Options();
o2.inSampleSize = scale;
return BitmapFactory.decodeStream(new FileInputStream(f), null, o2);
} catch (FileNotFoundException e) {
e.printStackTrace();
}
return null;
}
/**
* 获取合适的Bitmap平时获取Bitmap就用这个方法吧.
*
* @param path 路径.
* @param data byte[]数组.
* @param context 上下文
* @param uri uri
* @param target 模板宽或者高的大小.
* @param width 是否是宽度
* @return
*/
public static Bitmap getResizedBitmap(String path, byte[] data,
Context context, Uri uri, int target, boolean width) {
BitmapFactory.Options options = null;
if (target > 0) {
BitmapFactory.Options info = new BitmapFactory.Options();
//这里设置true的时候，decode时候Bitmap返回的为空，
//将图片宽高读取放在Options里.
info.inJustDecodeBounds = false;
decode(path, data, context, uri, info);
int dim = info.outWidth;
if (!width)
dim = Math.max(dim, info.outHeight);
int ssize = sampleSize(dim, target);
options = new BitmapFactory.Options();
options.inSampleSize = ssize;
}
Bitmap bm = null;
try {
bm = decode(path, data, context, uri, options);
} catch (Exception e) {
e.printStackTrace();
}
return bm;
}
/**
* 解析Bitmap的公用方法.
*
* @param path
* @param data
* @param context
* @param uri
* @param options
* @return
*/
public static Bitmap decode(String path, byte[] data, Context context,
Uri uri, BitmapFactory.Options options) {
Bitmap result = null;
if (path != null) {
result = BitmapFactory.decodeFile(path, options);
} else if (data != null) {
result = BitmapFactory.decodeByteArray(data, 0, data.length,
options);
} else if (uri != null) {
//uri不为空的时候context也不要为空.
ContentResolver cr = context.getContentResolver();
InputStream inputStream = null;
try {
inputStream = cr.openInputStream(uri);
result = BitmapFactory.decodeStream(inputStream, null, options);
inputStream.close();
} catch (Exception e) {
e.printStackTrace();
}
}
return result;
}
/**
* 获取合适的sampleSize.
* 这里就简单实现都是2的倍数啦.
*
* @param width
* @param target
* @return
*/
private static int sampleSize(int width, int target) {
int result = 1;
for (int i = 0; i < 10; i++) {
if (width < target * 2) {
break;
}
width = width / 2;
result = result * 2;
}
return result;
}
public static Bitmap decodeSampledBitmapFromResource(Resources res, int resId,
int reqWidth, int reqHeight) {
// First decode with inJustDecodeBounds=true to check dimensions
final BitmapFactory.Options options = new BitmapFactory.Options();
options.inJustDecodeBounds = true;
BitmapFactory.decodeResource(res, resId, options);
// Calculate inSampleSize
options.inSampleSize = calculateInSampleSize(options, reqWidth, reqHeight);
// Decode bitmap with inSampleSize set
options.inJustDecodeBounds = false;
return BitmapFactory.decodeResource(res, resId, options);
}
public static Bitmap decodeSampledBitmapFromResource(Resources res, InputStream inputStream,
int reqWidth, int reqHeight) {
// First decode with inJustDecodeBounds=true to check dimensions
final BitmapFactory.Options options = new BitmapFactory.Options();
options.inJustDecodeBounds = true;
BitmapFactory.decodeStream(inputStream, null, options);
// Calculate inSampleSize
options.inSampleSize = calculateInSampleSize(options, reqWidth, reqHeight);
// Decode bitmap with inSampleSize set
options.inJustDecodeBounds = false;
return BitmapFactory.decodeStream(inputStream, null, options);
}
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) {
final int halfHeight = height / 2;
final int halfWidth = width / 2;
// Calculate the largest inSampleSize value that is a power of 2 and keeps both
// height and width larger than the requested height and width.
while ((halfHeight / inSampleSize) > reqHeight
&& (halfWidth / inSampleSize) > reqWidth) {
inSampleSize *= 2;
}
}
return inSampleSize;
}
public static InputStream bitmapToInputStream(Bitmap bitmap) {
ByteArrayOutputStream bos = new ByteArrayOutputStream();
bitmap.compress(Bitmap.CompressFormat.PNG, 0 /*ignored for PNG*/, bos);
byte[] bitmapdata = bos.toByteArray();
ByteArrayInputStream bs = new ByteArrayInputStream(bitmapdata);
return bs;
}
public static Bitmap getBitmapFromResource(Context ctx, int resDrawable) {
BitmapFactory.Options bitmapOptions = new BitmapFactory.Options();
bitmapOptions.inPreferredConfig = Bitmap.Config.RGB_565;
return BitmapFactory.decodeResource(ctx.getResources(), resDrawable, bitmapOptions);
}
}