难以理解Android'；s doc关于缩小大型位图的比例
我的问题是：这个文档为什么会存在，并且被发布和重新发布了很多次，而从来没有人遇到过它的问题。我的结论是，我误解了代码的逻辑或整个主题，但有人能解释一下吗？故事是这样的： 我正在尝试缩小一个大位图，下面是android的文档： 更具体地说，使用此代码段：难以理解Android'；s doc关于缩小大型位图的比例,android,bitmap,scale,Android,Bitmap,Scale,我的问题是：这个文档为什么会存在，并且被发布和重新发布了很多次，而从来没有人遇到过它的问题。我的结论是，我误解了代码的逻辑或整个主题，但有人能解释一下吗？故事是这样的： 我正在尝试缩小一个大位图，下面是android的文档： 更具体地说，使用此代码段： public static int calculateInSampleSize( BitmapFactory.Options options, int reqWidth, int reqHeight) { //
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 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;
// 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 ((height / inSampleSize) > reqHeight
|| (width / inSampleSize) > reqWidth) {
inSampleSize *= 2;
}
return inSampleSize;
}
导入android.content.Context；
import android.content.Context;
import android.database.Cursor;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.graphics.Canvas;
import android.graphics.Matrix;
import android.graphics.Paint;
import android.media.ExifInterface;
import android.net.Uri;
import android.provider.MediaStore;
import com.serviceledger.corporatefloor.modals.ImageData;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
/**
* Created by rohit.h on 1/29/2016.
*/
public class ImageCompresser {
private static ImageCompresser instance;
private ImageCompresser() {
}
public static ImageCompresser getInstance() {
if (instance == null) {
instance = new ImageCompresser();
}
return instance;
}
public ImageData compressImage(Context mContext,String imageUri) {
String filePath = imageUri;
// String filePath = getRealPathFromURI(imageUri);
Bitmap scaledBitmap = null;
BitmapFactory.Options options = new BitmapFactory.Options();
// by setting this field as true, the actual bitmap pixels are not
// loaded in the memory. Just the bounds are loaded. If
// you try the use the bitmap here, you will get null.
options.inJustDecodeBounds = true;
Bitmap bmp = BitmapFactory.decodeFile(filePath, options);
int actualHeight = options.outHeight;
int actualWidth = options.outWidth;
// max Height and width values of the compressed image is taken as
// 816x612
/*
* float maxHeight = 816.0f; float maxWidth = 612.0f;
*/
float maxHeight = 1080.0f;
float maxWidth = 800.0f;
float imgRatio = actualWidth / (float) actualHeight;
float maxRatio = maxWidth / (float) maxHeight;
// width and height values are set maintaining the aspect ratio of the
// image
if (actualHeight > maxHeight || actualWidth > maxWidth) {
if (imgRatio < maxRatio) {
imgRatio = maxHeight / actualHeight;
actualWidth = (int) (imgRatio * actualWidth);
actualHeight = (int) maxHeight;
} else if (imgRatio > maxRatio) {
imgRatio = maxWidth / actualWidth;
actualHeight = (int) (imgRatio * actualHeight);
actualWidth = (int) maxWidth;
} else {
actualHeight = (int) maxHeight;
actualWidth = (int) maxWidth;
}
}
// setting inSampleSize value allows to load a scaled down version of
// the original image
options.inSampleSize = calculateInSampleSize(options, actualWidth, actualHeight);
// inJustDecodeBounds set to false to load the actual bitmap
options.inJustDecodeBounds = false;
// this options allow android to claim the bitmap memory if it runs low
// on memory
options.inPurgeable = true;
options.inInputShareable = true;
options.inTempStorage = new byte[16 * 1024];
try {
// load the bitmap from its path
bmp = BitmapFactory.decodeFile(filePath, options);
} catch (OutOfMemoryError exception) {
exception.printStackTrace();
}
try {
scaledBitmap = Bitmap.createBitmap(actualWidth, actualHeight, Bitmap.Config.ARGB_8888);
} catch (OutOfMemoryError exception) {
exception.printStackTrace();
}
float ratioX = actualWidth / (float) options.outWidth;
float ratioY = actualHeight / (float) options.outHeight;
float middleX = actualWidth / 2.0f;
float middleY = actualHeight / 2.0f;
Matrix scaleMatrix = new Matrix();
scaleMatrix.setScale(ratioX, ratioY, middleX, middleY);
Canvas canvas = new Canvas(scaledBitmap);
canvas.setMatrix(scaleMatrix);
canvas.drawBitmap(bmp, middleX - bmp.getWidth() / 2, middleY - bmp.getHeight() / 2, new Paint(Paint.FILTER_BITMAP_FLAG));
// check the rotation of the image and display it properly
ExifInterface exif;
try {
exif = new ExifInterface(filePath);
int orientation = exif.getAttributeInt(ExifInterface.TAG_ORIENTATION, 0);
// displayLogs("EXIF", "Exif: " + orientation);
Matrix matrix = new Matrix();
if (orientation == 6) {
matrix.postRotate(90);
// displayLogs("EXIF", "Exif: " + orientation);
} else if (orientation == 3) {
matrix.postRotate(180);
// displayLogs("EXIF", "Exif: " + orientation);
} else if (orientation == 8) {
matrix.postRotate(270);
// displayLogs("EXIF", "Exif: " + orientation);
}
scaledBitmap = Bitmap.createBitmap(scaledBitmap, 0, 0, scaledBitmap.getWidth(), scaledBitmap.getHeight(), matrix, true);
} catch (IOException e) {
e.printStackTrace();
}
FileOutputStream out = null;
String filename = getFilename(mContext,filePath);
// File image = new File(getFilename(), System.currentTimeMillis() +
// ".jpg");
try {
out = new FileOutputStream(filename);
// write the compressed bitmap at the destination specified by
// filename.
boolean didWrite = scaledBitmap.compress(Bitmap.CompressFormat.JPEG, 80, out);
out.close();
System.out.println(didWrite);
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
ImageData data = new ImageData();
data.setBitmap(scaledBitmap);
data.setUrl(filename);
return data;
}
private String getRealPathFromURI(Context mContext,String contentURI) {
Uri contentUri = Uri.parse(contentURI);
Cursor cursor = mContext.getContentResolver().query(contentUri, null, null, null, null);
if (cursor == null) {
return contentUri.getPath();
} else {
cursor.moveToFirst();
int index = cursor.getColumnIndex(MediaStore.Images.ImageColumns.DATA);
return cursor.getString(index);
}
}
public int calculateInSampleSize(BitmapFactory.Options options, int reqWidth, int reqHeight) {
final int height = options.outHeight;
final int width = options.outWidth;
int inSampleSize = 1;
if (height > reqHeight || width > reqWidth) {
final int heightRatio = Math.round((float) height / (float) reqHeight);
final int widthRatio = Math.round((float) width / (float) reqWidth);
inSampleSize = heightRatio < widthRatio ? heightRatio : widthRatio;
}
final float totalPixels = width * height;
final float totalReqPixelsCap = reqWidth * reqHeight * 2;
while (totalPixels / (inSampleSize * inSampleSize) > totalReqPixelsCap) {
inSampleSize++;
}
return inSampleSize;
}
private String getFilename(Context mContext,String originalname) {
ImageCache imageCache = new ImageCache(mContext);
File file = imageCache.getCacheDirectory();
// return file;
String uriSting = (file.getAbsolutePath() + "/" + "F_" + System.currentTimeMillis() + ".png");
return uriSting;
}
}
Second class:
public class ImageCache {
private File cacheDir;
public ImageCache(Context context){
//Find the dir to save cached images
if (android.os.Environment.getExternalStorageState().equals(android.os.Environment.MEDIA_MOUNTED)){
cacheDir=new File(android.os.Environment.getExternalStorageDirectory(),"yourpackagename");
}
else{
cacheDir=context.getCacheDir();
}
if(!cacheDir.exists()){
cacheDir.mkdirs();
}
}
public File getCacheDirectory(){
return cacheDir;
}
public File getFile(String url){
//I identify images by hashcode. Not a perfect solution, good for the demo.
String filename=String.valueOf(url.hashCode());
//Another possible solution (thanks to grantland)
//String filename = URLEncoder.encode(url);
File f = new File(cacheDir, filename);
return f;
}
public void clear(){
File[] files=cacheDir.listFiles();
if(files==null)
return;
for(File f:files)
f.delete();
}
ModalClass:-
public class ImageData {
private String Url;
private Bitmap bitmap;
public boolean isImageAvailable() {
return isImageAvailable;
}
public void setIsImageAvailable(boolean isImageAvailable) {
this.isImageAvailable = isImageAvailable;
}
private boolean isImageAvailable;
public boolean isImageDeleteable() {
return isImageDeleteable;
}
public void setIsImageDeleteable(boolean isImageDeleteable) {
this.isImageDeleteable = isImageDeleteable;
}
private boolean isImageDeleteable;
public Bitmap getBitmap() {
return bitmap;
}
public void setBitmap(Bitmap bitmap) {
this.bitmap = bitmap;
}
public String getUrl() {
return Url;
}
public void setUrl(String url) {
Url = url;
}
}
导入android.database.Cursor；
导入android.graphics.Bitmap；
导入android.graphics.BitmapFactory；
导入android.graphics.Canvas；
导入android.graphics.Matrix；
导入android.graphics.Paint；
导入android.media.ExifInterface；
导入android.net.Uri；
导入android.provider.MediaStore；
导入com.serviceledger.corporatefoor.modals.ImageData；
导入java.io.File；
导入java.io.FileNotFoundException；
导入java.io.FileOutputStream；
导入java.io.IOException；
/**
*由rohit.h于2016年1月29日创建。
*/
公共级图象压缩机{
私有静态图像压缩实例；
专用图像压缩程序（）{
}
公共静态图像压缩程序getInstance（）{
if（实例==null）{
实例=新的图像压缩程序（）；
}
返回实例；
}
公共图像数据压缩图像（上下文mContext，字符串imageUri）{
字符串filePath=imageUri；
//字符串filePath=getRealPathFromURI（imageUri）；
位图缩放位图=空；
BitmapFactory.Options=new-BitmapFactory.Options（）；
//通过将此字段设置为true，实际位图像素将不显示
//加载到内存中。仅加载边界。如果
//如果您尝试在此处使用位图，将得到null。
options.inJustDecodeBounds=true；
位图bmp=BitmapFactory.decodeFile（文件路径，选项）；
int实际高度=options.outHeight；
int actualWidth=options.outWidth；
//压缩图像的最大高度和宽度值取为
//816x612
/*
*浮动最大高度=816.0f；浮动最大宽度=612.0f；
*/
浮动最大高度=1080.0f；
浮动最大宽度=800.0f；
浮动高度=实际宽度/（浮动）实际高度；
浮动最大比率=最大宽度/（浮动）最大高度；
//设置“宽度”和“高度”值以保持图形的纵横比
//形象
如果（实际高度>最大高度| |实际宽度>最大宽度）{
if（imgRatiomaxRatio）{
imgRatio=最大宽度/实际宽度；
实际高度=（int）（imgRatio*实际高度）；
实际宽度=（int）最大宽度；
}否则{
实际高度=（int）最大高度；
实际宽度=（int）最大宽度；
}
}
//设置inSampleSize值允许加载的缩小版本
//原始图像
options.inSampleSize=calculateInSampleSize（选项、实际宽度、实际高度）；
//inJustDecodeBounds设置为false以加载实际位图
options.inJustDecodeBounds=false；
//此选项允许android在位图内存不足时声明位图内存
//关于记忆
options.inpurgable=true；
options.inInputShareable=true；
options.inTempStorage=新字节[16*1024]；
试一试{
//从位图路径加载位图
bmp=BitmapFactory.decodeFile（文件路径，选项）；
}捕获（OutOfMemoryError异常）{
异常。printStackTrace（）；
}
试一试{
scaledbimat=Bitmap.createBitmap（实际宽度、实际高度、Bitmap.Config.ARGB_8888）；
}捕获（OutOfMemoryError异常）{
异常。printStackTrace（）；
}
浮动比率=实际宽度/（浮动）选项。向外宽度；
浮动比率=实际高度/（浮动）选项。超出高度；
浮动中间点x=实际宽度/2.0f；
浮动中间Y=实际高度/2.0f；
矩阵scaleMatrix=新矩阵（）；
scaleMatrix.setScale（ratioX、ratioY、middleX、middleY）；
画布画布=新画布（缩放位图）；
canvas.setMatrix（scaleMatrix）；
drawBitmap（bmp，middleX-bmp.getWidth（）/2，middleY-bmp.getHeight（）/2，新绘制（Paint.FILTER_位图_标志））；
//检查图像的旋转并正确显示
出口接口；
试一试{
exif=新的ExifInterface（文件路径）；
int-orientation=exif.getAttributeInt（ExifInterface.TAG_-orientation，0）；
//显示日志（“EXIF”、“EXIF:+方向”）；
矩阵=新矩阵（）；
如果（方向==6）{
矩阵旋转后（90）；
//显示日志（“EXIF”、“EXIF:+方向”）；
}否则如果（方向==3）{
矩阵旋转后（180）；
//显示日志（“EXIF”、“EXIF:+方向”）；
}否则如果（方向==8）{
矩阵旋转后（270）；
//显示日志（“EXIF”、“EXIF:+方向”）；
}
scaledBitmap=Bitmap.createBitmap（scaledBitmap，0，0，scaledBitmap.getWidth（），scaledBitmap.getHeight（），矩阵，true）；
}捕获（IOE异常）{