blocks|key|116194|text|我最近写了这篇文章来缩放/裁剪图像到特定的分辨率，并以高质量压缩它：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|116195|public+static+void+scaleImageToResolution(Context+context,+File+image,+int+dstWidth,+int+dstHeight)+{
++++if+(dstHeight+>+0+&&+dstWidth+>+0+&&+image+!=+null)+{

++++++++Bitmap+result+=+null;
++++++++try+{
++++++++++++//Get+Image+Properties
++++++++++++BitmapFactory.Options+bmOptions+=+new+BitmapFactory.Options();
++++++++++++bmOptions.inJustDecodeBounds+=+true;
++++++++++++BitmapFactory.decodeFile(image.getAbsolutePath(),+bmOptions);
++++++++++++int+photoH+=+bmOptions.outHeight;
++++++++++++int+photoW+=+bmOptions.outWidth;

++++++++++++bmOptions.inJustDecodeBounds+=+false;
++++++++++++bmOptions.inPurgeable+=+true;
++++++++++++//Smaller+Image+Size+in+Memory+with+Config
++++++++++++bmOptions.inPreferredConfig+=+Bitmap.Config.RGB_565;

++++++++++++//Is+resolution+not+the+same+like+16:9+==+4:3+then+crop+otherwise+fit
++++++++++++ScalingLogic+scalingLogic+=+getScalingLogic(photoW,+photoH,dstWidth,+dstHeight);
++++++++++++//Get+Maximum+automatic+downscaling+that+it's+still+bigger+then+this+requested+resolution
++++++++++++bmOptions.inSampleSize+=+calculateScalingSampleSize(photoW,+photoH,+dstWidth,+dstHeight,+scalingLogic);

++++++++++++//Get+unscaled+Bitmap
++++++++++++result+=+BitmapFactory.decodeFile(image.getAbsolutePath(),+bmOptions);

++++++++++++//Scale+Bitmap+to+requested+Resolution
++++++++++++result+=+scaleImageToResolution(context,+result,+scalingLogic);

++++++++++++if+(result+!=+null)+{
++++++++++++++++//Save+Bitmap+with+quality
++++++++++++++++saveImageWithQuality(context,+result,+image);
++++++++++++}
++++++++}+finally+{
++++++++++++//Clear+Memory
++++++++++++if+(result+!=+null)
++++++++++++++++result.recycle();
++++++++}
++++}
}


public+static+void+saveImageWithQuality(Bitmap+bitmap,+String+path,+int+compressQuality)+{
++++try+{
++++++++FileOutputStream+fOut;
++++++++fOut+=+new+FileOutputStream(path);
++++++++bitmap.compress(Bitmap.CompressFormat.JPEG,+compressQuality,+fOut);
++++++++fOut.flush();
++++++++fOut.close();
++++}+catch+(IOException+ex)+{
++++++++if+(Logger.getRootLogger()+!=+null)
++++++++++++Logger.getRootLogger().error(ex);
++++++++else
++++++++++++Log.e("saveImageWithQuality",+"Error+while+saving+compressed+Picture:+"+%2B+ex.getMessage()+%2B+StringUtils.newLine()+%2B+ex.getStackTrace().toString());
++++}
}

public+static+void+saveImageWithQuality(Context+context,+Bitmap+bitmap,+File+file)+{
++++saveImageWithQuality(bitmap,+file.getAbsolutePath(),+getCompressQuality());
}

public+static+void+saveImageWithQuality(Context+context,+Bitmap+bitmap,+String+path)+{
++++saveImageWithQuality(bitmap,+path,+getCompressQuality());
}

private+static+int+calculateScalingSampleSize(int+srcWidth,+int+srcHeight,+int+dstWidth,+int+dstHeight,+ScalingLogic+scalingLogic)+{
++++if+(scalingLogic+==+ScalingLogic.FIT)+{
++++++++final+float+srcAspect+=+(float)+srcWidth+/+(float)+srcHeight;
++++++++final+float+dstAspect+=+(float)+dstWidth+/+(float)+dstHeight;

++++++++if+(srcAspect+>+dstAspect)+{
++++++++++++return+srcWidth+/+dstWidth;
++++++++}+else+{
++++++++++++return+srcHeight+/+dstHeight;
++++++++}
++++}+else+{
++++++++final+float+srcAspect+=+(float)+srcWidth+/+(float)+srcHeight;
++++++++final+float+dstAspect+=+(float)+dstWidth+/+(float)+dstHeight;

++++++++if+(srcAspect+>+dstAspect)+{
++++++++++++return+srcHeight+/+dstHeight;
++++++++}+else+{
++++++++++++return+srcWidth+/+dstWidth;
++++++++}
++++}
}

private+static+Bitmap+scaleImageToResolution(Context+context,+Bitmap+unscaledBitmap,+ScalingLogic+scalingLogic,+int+dstWidth,+int+dstHeight)+{
++++//Do+Rectangle+of+original+picture+when+crop
++++Rect+srcRect+=+calculateSrcRect(unscaledBitmap.getWidth(),+unscaledBitmap.getHeight(),+dstWidth,+dstHeight,+scalingLogic);
++++//Do+Rectangle+to+fit+in+the+source+rectangle
++++Rect+dstRect+=+calculateDstRect(unscaledBitmap.getWidth(),+unscaledBitmap.getHeight(),+dstWidth,+dstHeight,+scalingLogic);
++++//insert+source+rectangle+into+new+one
++++Bitmap+scaledBitmap+=+Bitmap.createBitmap(dstRect.width(),+dstRect.height(),+Bitmap.Config.ARGB_8888);
++++Canvas+canvas+=+new+Canvas(scaledBitmap);
++++canvas.drawBitmap(unscaledBitmap,+srcRect,+dstRect,+new+Paint(Paint.FILTER_BITMAP_FLAG));
++++//Recycle+the+unscaled+Bitmap+afterwards
++++unscaledBitmap.recycle();

++++return+scaledBitmap;
}

private+static+Rect+calculateSrcRect(int+srcWidth,+int+srcHeight,+int+dstWidth,+int+dstHeight,+ScalingLogic+scalingLogic)+{
++++if+(scalingLogic+==+ScalingLogic.CROP)+{
++++++++if+(srcWidth+>=+srcHeight)+{
++++++++++++//Horizontal
++++++++++++final+float+srcAspect+=+(float)+srcWidth+/+(float)+srcHeight;
++++++++++++final+float+dstAspect+=+(float)+dstWidth+/+(float)+dstHeight;

++++++++++++if+(srcAspect+<+dstAspect+%7C%7C+isResolutionEqual(srcAspect,+dstAspect))+{
++++++++++++++++final+int+srcRectHeight+=+(int)+(srcWidth+/+dstAspect);
++++++++++++++++final+int+scrRectTop+=+(srcHeight+-+srcRectHeight)+/+2;
++++++++++++++++return+new+Rect(0,+scrRectTop,+srcWidth,+scrRectTop+%2B+srcRectHeight);
++++++++++++}+else+{
++++++++++++++++final+int+srcRectWidth+=+(int)+(srcHeight+*+dstAspect);
++++++++++++++++final+int+srcRectLeft+=+(srcWidth+-+srcRectWidth)+/+2;
++++++++++++++++return+new+Rect(srcRectLeft,+0,+srcRectLeft+%2B+srcRectWidth,+srcHeight);
++++++++++++}
++++++++}+else+{
++++++++++++//Vertikal
++++++++++++final+float+srcAspect+=+(float)+srcHeight+/+(float)+srcWidth;
++++++++++++final+float+dstAspect+=+(float)+dstWidth+/+(float)+dstHeight;

++++++++++++if+(srcAspect+<+dstAspect+%7C%7C+isResolutionEqual(srcAspect,+dstAspect))+{
++++++++++++++++final+int+srcRectWidth+=+(int)+(srcHeight+/+dstAspect);
++++++++++++++++final+int+srcRectLeft+=+(srcWidth+-+srcRectWidth)+/+2;
++++++++++++++++return+new+Rect(srcRectLeft,+0,+srcRectLeft+%2B+srcRectWidth,+srcHeight);
++++++++++++}+else+{
++++++++++++++++final+int+srcRectHeight+=+(int)+(srcWidth+*+dstAspect);
++++++++++++++++final+int+scrRectTop+=+(srcHeight+-+srcRectHeight)+/+2;
++++++++++++++++return+new+Rect(0,+scrRectTop,+srcWidth,+scrRectTop+%2B+srcRectHeight);
++++++++++++}
++++++++}
++++}+else+{
++++++++return+new+Rect(0,+0,+srcWidth,+srcHeight);
++++}
}

private+static+Rect+calculateDstRect(int+srcWidth,+int+srcHeight,+int+dstWidth,+int+dstHeight,+ScalingLogic+scalingLogic)+{
++++if+(scalingLogic+==+ScalingLogic.FIT)+{
++++++++if+(srcWidth+>+srcHeight)+{
++++++++++++//Vertikal
++++++++++++final+float+srcAspect+=+(float)+srcWidth+/+(float)+srcHeight;
++++++++++++final+float+dstAspect+=+(float)+dstWidth+/+(float)+dstHeight;

++++++++++++if+(srcAspect+<+dstAspect+%7C%7C+isResolutionEqual(srcAspect,+dstAspect))+{
++++++++++++++++return+new+Rect(0,+0,+(int)+(dstHeight+*+srcAspect),+dstHeight);
++++++++++++}+else+{
++++++++++++++++return+new+Rect(0,+0,+dstWidth,+(int)+(dstWidth+/+srcAspect));
++++++++++++}
++++++++}+else+{
++++++++++++//Horizontal
++++++++++++final+float+srcAspect+=+(float)+srcHeight+/+(float)+srcWidth;
++++++++++++final+float+dstAspect+=+(float)+dstWidth+/+(float)+dstHeight;

++++++++++++if+(srcAspect+<+dstAspect+%7C%7C+isResolutionEqual(srcAspect,+dstAspect))+{
++++++++++++++++return+new+Rect(0,+0,+(int)+(dstHeight+/+srcAspect),+dstHeight);
++++++++++++}+else+{
++++++++++++++++return+new+Rect(0,+0,+dstWidth,+(int)+(dstWidth+*+srcAspect));
++++++++++++}
++++++++}
++++}+else+{
++++++++if+(srcWidth+>=+srcHeight)
++++++++++++return+new+Rect(0,+0,+dstWidth,+dstHeight);
++++++++else
++++++++++++return+new+Rect(0,+0,+dstHeight,+dstWidth);
++++}
}

private+static+ScalingLogic+getScalingLogic(int+imageWidth,+int+imageHeight,+int+dstResolutionWidth,+int+dstResolutionHeight)+{
++++if+(imageWidth+>=+imageHeight)+{
++++++++//Bild+horizontal
++++++++final+float+srcAspect+=+(float)+imageWidth+/+(float)+imageHeight;
++++++++final+float+dstAspect+=+(float)+dstResolutionWidth+/+(float)+dstResolutionHeight;
++++++++if+(!isResolutionEqual(srcAspect,+dstAspect))+{
++++++++++++return+ScalingLogic.CROP;
++++++++}+else+{
++++++++++++return+ScalingLogic.FIT;
++++++++}
++++}+else+{
++++++++//Bild+vertikal
++++++++final+float+srcAspect+=+(float)+imageHeight+/+(float)+imageWidth;
++++++++final+float+dstAspect+=+(float)+dstResolutionWidth+/+(float)+dstResolutionHeight;
++++++++if+(!isResolutionEqual(srcAspect,+dstAspect))+{
++++++++++++return+ScalingLogic.CROP;
++++++++}+else+{
++++++++++++return+ScalingLogic.FIT;
++++++++}
++++}
}

public+enum+PictureQuality+{
++++High,
++++Medium,
++++Low
}

public+enum+ScalingLogic+{
++++CROP,
++++FIT
}

//Does+resolution+match
private+static+boolean+isResolutionEqual(float+v1,+float+v2)+{
++++//+Falls+a+1.999999999999+and+b+=+2.000000000000
++++return+v1+==+v2+%7C%7C+Math.abs(v1+-+v2)+/+Math.max(Math.abs(v1),+Math.abs(v2))+<+0.01;
}

public+int+getCompressQuality()+{
++++if+(Quality+==+PictureQuality.High)
++++++++return+100;
++++else+if+(Quality+==+PictureQuality.Medium)
++++++++return+50;
++++else+if+(Quality+==+PictureQuality.Low)
++++++++return+25;
++++else+return+0;
}|code-block|syntax|javascript|116196|它没有使用你提到的库，但它可以工作，我对它很满意。也许你也是。|116197|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

I recently wrote this to scale/crop an image to a specific resolution and compress it with quality:

<pre><code>public static void scaleImageToResolution(Context context, File image, int dstWidth, int dstHeight) {
 if (dstHeight &gt; 0 &amp;&amp; dstWidth &gt; 0 &amp;&amp; image != null) {

 Bitmap result = null;
 try {
 //Get Image Properties
 BitmapFactory.Options bmOptions = new BitmapFactory.Options();
 bmOptions.inJustDecodeBounds = true;
 BitmapFactory.decodeFile(image.getAbsolutePath(), bmOptions);
 int photoH = bmOptions.outHeight;
 int photoW = bmOptions.outWidth;

 bmOptions.inJustDecodeBounds = false;
 bmOptions.inPurgeable = true;
 //Smaller Image Size in Memory with Config
 bmOptions.inPreferredConfig = Bitmap.Config.RGB_565;

 //Is resolution not the same like 16:9 == 4:3 then crop otherwise fit
 ScalingLogic scalingLogic = getScalingLogic(photoW, photoH,dstWidth, dstHeight);
 //Get Maximum automatic downscaling that it's still bigger then this requested resolution
 bmOptions.inSampleSize = calculateScalingSampleSize(photoW, photoH, dstWidth, dstHeight, scalingLogic);

 //Get unscaled Bitmap
 result = BitmapFactory.decodeFile(image.getAbsolutePath(), bmOptions);

 //Scale Bitmap to requested Resolution
 result = scaleImageToResolution(context, result, scalingLogic);

 if (result != null) {
 //Save Bitmap with quality
 saveImageWithQuality(context, result, image);
 }
 } finally {
 //Clear Memory
 if (result != null)
 result.recycle();
 }
 }
}


public static void saveImageWithQuality(Bitmap bitmap, String path, int compressQuality) {
 try {
 FileOutputStream fOut;
 fOut = new FileOutputStream(path);
 bitmap.compress(Bitmap.CompressFormat.JPEG, compressQuality, fOut);
 fOut.flush();
 fOut.close();
 } catch (IOException ex) {
 if (Logger.getRootLogger() != null)
 Logger.getRootLogger().error(ex);
 else
 Log.e("saveImageWithQuality", "Error while saving compressed Picture: " + ex.getMessage() + StringUtils.newLine() + ex.getStackTrace().toString());
 }
}

public static void saveImageWithQuality(Context context, Bitmap bitmap, File file) {
 saveImageWithQuality(bitmap, file.getAbsolutePath(), getCompressQuality());
}

public static void saveImageWithQuality(Context context, Bitmap bitmap, String path) {
 saveImageWithQuality(bitmap, path, getCompressQuality());
}

private static int calculateScalingSampleSize(int srcWidth, int srcHeight, int dstWidth, int dstHeight, ScalingLogic scalingLogic) {
 if (scalingLogic == ScalingLogic.FIT) {
 final float srcAspect = (float) srcWidth / (float) srcHeight;
 final float dstAspect = (float) dstWidth / (float) dstHeight;

 if (srcAspect &gt; dstAspect) {
 return srcWidth / dstWidth;
 } else {
 return srcHeight / dstHeight;
 }
 } else {
 final float srcAspect = (float) srcWidth / (float) srcHeight;
 final float dstAspect = (float) dstWidth / (float) dstHeight;

 if (srcAspect &gt; dstAspect) {
 return srcHeight / dstHeight;
 } else {
 return srcWidth / dstWidth;
 }
 }
}

private static Bitmap scaleImageToResolution(Context context, Bitmap unscaledBitmap, ScalingLogic scalingLogic, int dstWidth, int dstHeight) {
 //Do Rectangle of original picture when crop
 Rect srcRect = calculateSrcRect(unscaledBitmap.getWidth(), unscaledBitmap.getHeight(), dstWidth, dstHeight, scalingLogic);
 //Do Rectangle to fit in the source rectangle
 Rect dstRect = calculateDstRect(unscaledBitmap.getWidth(), unscaledBitmap.getHeight(), dstWidth, dstHeight, scalingLogic);
 //insert source rectangle into new one
 Bitmap scaledBitmap = Bitmap.createBitmap(dstRect.width(), dstRect.height(), Bitmap.Config.ARGB_8888);
 Canvas canvas = new Canvas(scaledBitmap);
 canvas.drawBitmap(unscaledBitmap, srcRect, dstRect, new Paint(Paint.FILTER_BITMAP_FLAG));
 //Recycle the unscaled Bitmap afterwards
 unscaledBitmap.recycle();

 return scaledBitmap;
}

private static Rect calculateSrcRect(int srcWidth, int srcHeight, int dstWidth, int dstHeight, ScalingLogic scalingLogic) {
 if (scalingLogic == ScalingLogic.CROP) {
 if (srcWidth &gt;= srcHeight) {
 //Horizontal
 final float srcAspect = (float) srcWidth / (float) srcHeight;
 final float dstAspect = (float) dstWidth / (float) dstHeight;

 if (srcAspect &lt; dstAspect || isResolutionEqual(srcAspect, dstAspect)) {
 final int srcRectHeight = (int) (srcWidth / dstAspect);
 final int scrRectTop = (srcHeight - srcRectHeight) / 2;
 return new Rect(0, scrRectTop, srcWidth, scrRectTop + srcRectHeight);
 } else {
 final int srcRectWidth = (int) (srcHeight * dstAspect);
 final int srcRectLeft = (srcWidth - srcRectWidth) / 2;
 return new Rect(srcRectLeft, 0, srcRectLeft + srcRectWidth, srcHeight);
 }
 } else {
 //Vertikal
 final float srcAspect = (float) srcHeight / (float) srcWidth;
 final float dstAspect = (float) dstWidth / (float) dstHeight;

 if (srcAspect &lt; dstAspect || isResolutionEqual(srcAspect, dstAspect)) {
 final int srcRectWidth = (int) (srcHeight / dstAspect);
 final int srcRectLeft = (srcWidth - srcRectWidth) / 2;
 return new Rect(srcRectLeft, 0, srcRectLeft + srcRectWidth, srcHeight);
 } else {
 final int srcRectHeight = (int) (srcWidth * dstAspect);
 final int scrRectTop = (srcHeight - srcRectHeight) / 2;
 return new Rect(0, scrRectTop, srcWidth, scrRectTop + srcRectHeight);
 }
 }
 } else {
 return new Rect(0, 0, srcWidth, srcHeight);
 }
}

private static Rect calculateDstRect(int srcWidth, int srcHeight, int dstWidth, int dstHeight, ScalingLogic scalingLogic) {
 if (scalingLogic == ScalingLogic.FIT) {
 if (srcWidth &gt; srcHeight) {
 //Vertikal
 final float srcAspect = (float) srcWidth / (float) srcHeight;
 final float dstAspect = (float) dstWidth / (float) dstHeight;

 if (srcAspect &lt; dstAspect || isResolutionEqual(srcAspect, dstAspect)) {
 return new Rect(0, 0, (int) (dstHeight * srcAspect), dstHeight);
 } else {
 return new Rect(0, 0, dstWidth, (int) (dstWidth / srcAspect));
 }
 } else {
 //Horizontal
 final float srcAspect = (float) srcHeight / (float) srcWidth;
 final float dstAspect = (float) dstWidth / (float) dstHeight;

 if (srcAspect &lt; dstAspect || isResolutionEqual(srcAspect, dstAspect)) {
 return new Rect(0, 0, (int) (dstHeight / srcAspect), dstHeight);
 } else {
 return new Rect(0, 0, dstWidth, (int) (dstWidth * srcAspect));
 }
 }
 } else {
 if (srcWidth &gt;= srcHeight)
 return new Rect(0, 0, dstWidth, dstHeight);
 else
 return new Rect(0, 0, dstHeight, dstWidth);
 }
}

private static ScalingLogic getScalingLogic(int imageWidth, int imageHeight, int dstResolutionWidth, int dstResolutionHeight) {
 if (imageWidth &gt;= imageHeight) {
 //Bild horizontal
 final float srcAspect = (float) imageWidth / (float) imageHeight;
 final float dstAspect = (float) dstResolutionWidth / (float) dstResolutionHeight;
 if (!isResolutionEqual(srcAspect, dstAspect)) {
 return ScalingLogic.CROP;
 } else {
 return ScalingLogic.FIT;
 }
 } else {
 //Bild vertikal
 final float srcAspect = (float) imageHeight / (float) imageWidth;
 final float dstAspect = (float) dstResolutionWidth / (float) dstResolutionHeight;
 if (!isResolutionEqual(srcAspect, dstAspect)) {
 return ScalingLogic.CROP;
 } else {
 return ScalingLogic.FIT;
 }
 }
}

public enum PictureQuality {
 High,
 Medium,
 Low
}

public enum ScalingLogic {
 CROP,
 FIT
}

//Does resolution match
private static boolean isResolutionEqual(float v1, float v2) {
 // Falls a 1.999999999999 and b = 2.000000000000
 return v1 == v2 || Math.abs(v1 - v2) / Math.max(Math.abs(v1), Math.abs(v2)) &lt; 0.01;
}

public int getCompressQuality() {
 if (Quality == PictureQuality.High)
 return 100;
 else if (Quality == PictureQuality.Medium)
 return 50;
 else if (Quality == PictureQuality.Low)
 return 25;
 else return 0;
}
</code></pre>

it's not using the libraries you mentioned but it works and I am happy with it. Maybe you are, too.

blocks|key|113767|text|不幸的是，安卓使用了java中不存在的android.graphics.Bitmap，而java使用了安卓中不存在的java.awt.image.BufferedImage+:-(|type|unstyled|depth|inlineStyleRanges|entityRanges|data|113768|我没有a+ready+to+use+library+for+android，但有一条路径可以将java-awt特定的库移植到平台独立的java库中，该库由android和awt/j2se的特定处理程序提供。|offset|length|style|CODE|113769|在java+rescale库中，你必须将所有java-awt特定的类(比如BufferedImage)隐藏在一个接口IBitmap后面，并为j2se实现该接口，为Android独立实现该接口。|113770|我已经成功地完成了exif/icc/ipc元数据处理，并在j2se+pixymeta-j2se-lib/.../j2se/BitmapNative.java和android+pixymeta-android-lib/.../android/BitmapNative.java上实现了pixymeta-lib/.../IBitmap.java接口。|113771|所以我有这些包|113772|113773|pixymeta-lib+|unordered-list-item|113774|转换了独立于平台的库，其中所有awt-reference都被IBitmap+#en0#+lib替换|113775|113776|113777|​|113778|IBitmap的|113779|pixymeta-j2se-lib+|113780|awt/j2se实现|113781|113782|113783|113784|113785|pixymeta-android-lib+|113786|安卓实现|113787|113788|113789|113790|entityMap|0|LINK|mutability|MUTABLE|url|https://github.com/k3b/pixymeta-android/blob/gradle-build/pixymeta-j2se-lib/src/main/java/pixy/j2se/BitmapNative.java|1|https://github.com/k3b/pixymeta-android/blob/gradle-build/pixymeta-android-lib/src/main/java/pixy/android/BitmapNative.java|2|https://github.com/k3b/pixymeta-android/blob/gradle-build/pixymeta-lib/src/main/java/pixy/image/IBitmap.java^0|0|3|Y|0|1M|7|0|Y|18|0|2F|1E|1|3X|T|2|0|0|0|1|U|7|1|0|0|0|0|7|0|1|1|0|0|0|0|7|0|1|1|0|0|0^^$0|@$1|2|3|4|5|6|7|1Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|1R|8|@$D|1S|E|1T|F|G]]|9|@]|A|$]]|$1|H|3|I|5|6|7|1U|8|@$D|1V|E|1W|F|G]]|9|@]|A|$]]|$1|J|3|K|5|6|7|1X|8|@]|9|@$D|1Y|E|1Z|1|20]|$D|21|E|22|1|23]|$D|24|E|25|1|26]]|A|$]]|$1|L|3|M|5|6|7|27|8|@]|9|@]|A|$]]|$1|N|3|-4|5|6|7|28|8|@]|9|@]|A|$]]|$1|O|3|P|5|Q|7|29|8|@]|9|@]|A|$]]|$1|R|3|S|5|Q|7|2A|8|@$D|2B|E|2C|F|G]]|9|@]|A|$]]|$1|T|3|-4|5|6|7|2D|8|@]|9|@]|A|$]]|$1|U|3|-4|5|6|7|2E|8|@]|9|@]|A|$]]|$1|V|3|W|5|6|7|2F|8|@]|9|@]|A|$]]|$1|X|3|Y|5|6|7|2G|8|@$D|2H|E|2I|F|G]]|9|@]|A|$]]|$1|Z|3|10|5|Q|7|2J|8|@]|9|@]|A|$]]|$1|11|3|12|5|Q|7|2K|8|@]|9|@]|A|$]]|$1|13|3|-4|5|6|7|2L|8|@]|9|@]|A|$]]|$1|14|3|-4|5|6|7|2M|8|@]|9|@]|A|$]]|$1|15|3|W|5|6|7|2N|8|@]|9|@]|A|$]]|$1|16|3|Y|5|6|7|2O|8|@$D|2P|E|2Q|F|G]]|9|@]|A|$]]|$1|17|3|18|5|Q|7|2R|8|@]|9|@]|A|$]]|$1|19|3|1A|5|Q|7|2S|8|@]|9|@]|A|$]]|$1|1B|3|-4|5|6|7|2T|8|@]|9|@]|A|$]]|$1|1C|3|-4|5|6|7|2U|8|@]|9|@]|A|$]]|$1|1D|3|W|5|6|7|2V|8|@]|9|@]|A|$]]|$1|1E|3|-4|5|6|7|2W|8|@]|9|@]|A|$]]]|1F|$1G|$5|1H|1I|1J|A|$1K|1L]]|1M|$5|1H|1I|1J|A|$1K|1N]]|1O|$5|1H|1I|1J|A|$1K|1P]]]]

Unfortunately Android uses android.graphics.Bitmap which does not exist in java
while java uses java.awt.image.BufferedImage that does not exist in android :-(

I donot have <code>a ready to use library for android</code> but a path how to port a java-awt specific lib to a platform independat java lib with platfrom specific handlers for android and awt/j2se

In the java rescale lib you have to hide all java-awt specific classes (like BufferedImage) behind an interface <code>IBitmap</code> and implement that interface for j2se and independantly for Android.

I have done this successfully for exif/icc/ipc metadata processing and implemented interface <a href="https://github.com/k3b/pixymeta-android/blob/gradle-build/pixymeta-lib/src/main/java/pixy/image/IBitmap.java">pixymeta-lib/.../IBitmap.java</a> with implementation for j2se <a href="https://github.com/k3b/pixymeta-android/blob/gradle-build/pixymeta-j2se-lib/src/main/java/pixy/j2se/BitmapNative.java">pixymeta-j2se-lib/.../j2se/BitmapNative.java</a> and android <a href="https://github.com/k3b/pixymeta-android/blob/gradle-build/pixymeta-android-lib/src/main/java/pixy/android/BitmapNative.java">pixymeta-android-lib/.../android/BitmapNative.java</a>

So I have these packages

<ul>
<li>pixymeta-lib

<ul>
<li>transformed platform independant lib where all awt-references are replaced by <code>IBitmap</code> interface</li>
</ul></li>
<li>pixymeta-j2se-lib 

<ul>
<li>awt/j2se implementation of <code>IBitmap</code></li>
</ul></li>
<li>pixymeta-android-lib

<ul>
<li>android implementation of <code>IBitmap</code></li>
</ul></li>
</ul>

blocks|key|2662947|text|最有希望的IMO是使用libswscale+(来自FFmpeg)，它提供了Lanczos和许多其他过滤器。要从本机代码访问Bitmap+buffer，可以使用jnigraphics。这种方法保证了良好的性能和可靠的结果。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|2662948|编辑|BOLD|2662949|Here你可以找到粗糙的演示应用程序，它使用了所提出的方法。目前的表现糟糕得令人沮丧，因此应该进行调查，以决定我们是否要做些什么来改善它。|2662950|entityMap|0|LINK|mutability|MUTABLE|url|https://ffmpeg.org/doxygen/3.1/group__libsws.html|1|https://developer.android.com/ndk/reference/bitmap_8h.html|2|https://github.com/ser-gik/smoothrescale^0|1P|6|B|A|0|27|B|1|0|0|2|0|0|4|2|0^^$0|@$1|2|3|4|5|6|7|W|8|@$9|X|A|Y|B|C]]|D|@$9|Z|A|10|1|11]|$9|12|A|13|1|14]]|E|$]]|$1|F|3|G|5|6|7|15|8|@$9|16|A|17|B|H]]|D|@]|E|$]]|$1|I|3|J|5|6|7|18|8|@]|D|@$9|19|A|1A|1|1B]]|E|$]]|$1|K|3|-4|5|6|7|1C|8|@]|D|@]|E|$]]]|L|$M|$5|N|O|P|E|$Q|R]]|S|$5|N|O|P|E|$Q|T]]|U|$5|N|O|P|E|$Q|V]]]]

The most promising IMO is to use <a href="https://ffmpeg.org/doxygen/3.1/group__libsws.html" rel="nofollow">libswscale</a> (from FFmpeg), it offers Lanczos and many other filters. To access <code>Bitmap</code> buffer from native code you can use <a href="https://developer.android.com/ndk/reference/bitmap_8h.html" rel="nofollow">jnigraphics</a>. This approach guarantees nice performance and reliable results.

EDIT

<a href="https://github.com/ser-gik/smoothrescale" rel="nofollow">Here</a> you can find rough demo app, that uses proposed approach. At the moment performance is frustratingly bad, so it should be investigated to decide if we to do something to improve it.

blocks|key|2662956|text|下面是我用来调整图像大小的代码。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2662957|Bitmap+photo1+;
private+byte[]+imageByteArray1+;


BitmapFactory.Options+opt1+=+new+BitmapFactory.Options();
opt1.inJustDecodeBounds=true;
BitmapFactory.decodeFile(imageUrl.get(imgCount).toString(),opt1);

//+The+new+size+we+want+to+scale+to
final+int+REQUIRED_SIZE=320;

//+Find+the+correct+scale+value.+It+should+be+the+power+of+2.
int+width_tmp=opt1.outWidth,height_tmp=opt1.outHeight;
int+scale=2;
while(true){
++++if(width_tmp>REQUIRED_SIZE%7C%7Cheight_tmp>REQUIRED_SIZE)
++++++++break;
++++width_tmp/=2;
++++height_tmp/=2;
++++scale*=2;
}
//+Decode+with+inSampleSize
BitmapFactory.Options+o2=new+BitmapFactory.Options();
o2.inSampleSize=scale;
o2.inJustDecodeBounds=false;
photo1=BitmapFactory.decodeFile(imageUrl.get(imgCount).toString(),o2);

ByteArrayOutputStream+baos1=new+ByteArrayOutputStream();
photo1.compress(Bitmap.CompressFormat.JPEG,60,baos1);
imageByteArray1=baos1.toByteArray();|code-block|syntax|javascript|2662958|希望它能帮助你..|2662959|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

Here is code that I've used for resize the image..

<pre><code>Bitmap photo1 ;
private byte[] imageByteArray1 ;


BitmapFactory.Options opt1 = new BitmapFactory.Options();
opt1.inJustDecodeBounds=true;
BitmapFactory.decodeFile(imageUrl.get(imgCount).toString(),opt1);

// The new size we want to scale to
final int REQUIRED_SIZE=320;

// Find the correct scale value. It should be the power of 2.
int width_tmp=opt1.outWidth,height_tmp=opt1.outHeight;
int scale=2;
while(true){
 if(width_tmp&gt;REQUIRED_SIZE||height_tmp&gt;REQUIRED_SIZE)
 break;
 width_tmp/=2;
 height_tmp/=2;
 scale*=2;
}
// Decode with inSampleSize
BitmapFactory.Options o2=new BitmapFactory.Options();
o2.inSampleSize=scale;
o2.inJustDecodeBounds=false;
photo1=BitmapFactory.decodeFile(imageUrl.get(imgCount).toString(),o2);

ByteArrayOutputStream baos1=new ByteArrayOutputStream();
photo1.compress(Bitmap.CompressFormat.JPEG,60,baos1);
imageByteArray1=baos1.toByteArray();
</code></pre>

Hope it will help you..

blocks|key|2873966|text|如果您只是想以一种针对显示目的进行优化的方式对图像进行重新采样，您可以使用这个漂亮的小线条，它为我提供了很好的服务。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2873967|Bitmap+bitmap+=+new+BitmapDrawable(getResources(),+yourBitmap).getBitmap();|code-block|syntax|javascript|2873968|这行代码可能看起来很奇怪，因为您将位图转换为BitmapDrawable，然后再转换回位图，但是BitmapDrawable默认为设备的像素密度(除非您使用不同的构造函数)。|2873969|如果您还需要调整大小，那么只需将其分成两行，并在将BitmapDrawable转换回位图之前使用setBounds，如下所示：|2873970|BitmapDrawable+bitmapDrawable+=+new+BitmapDrawable(getResources(),+yourBitmap);
bitmapDrawable.setBounds(left,+top,+right,+bottom);+//Make+it+a+new+size+in+pixels.
yourBitmap+=+bitmapDrawable.getBitmap();+//Convert+it+back+to+a+bitmap+optimised+for+display+purposes.|2873971|位图可绘制可能被列为已销毁，但它不是，只有特定的构造函数被销毁，并且上面示例中的构造函数没有被销毁。这也适用于API+4。|2873972|另外，android文档在这里提供了一个可供下载的示例：https://developer.android.com/topic/performance/graphics/load-bitmap.html|offset|length|2873973|希望这能有所帮助。|2873974|entityMap|0|LINK|mutability|MUTABLE|url|https://developer.android.com/topic/performance/graphics/load-bitmap.html^0|0|0|0|0|0|0|S|21|0|0|0^^$0|@$1|2|3|4|5|6|7|12|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|13|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|14|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|15|8|@]|9|@]|A|$]]|$1|K|3|L|5|D|7|16|8|@]|9|@]|A|$E|F]]|$1|M|3|N|5|6|7|17|8|@]|9|@]|A|$]]|$1|O|3|P|5|6|7|18|8|@]|9|@$Q|19|R|1A|1|1B]]|A|$]]|$1|S|3|T|5|6|7|1C|8|@]|9|@]|A|$]]|$1|U|3|-4|5|6|7|1D|8|@]|9|@]|A|$]]]|V|$W|$5|X|Y|Z|A|$10|11]]]]

If you just want to resample the image in a way that is optimized for display purposes you can use this nifty little one liner that has served me well.

<pre><code>Bitmap bitmap = new BitmapDrawable(getResources(), yourBitmap).getBitmap();
</code></pre>

This line of code may seem strange because you're converting a bitmap to a BitmapDrawable and back to a bitmap again but a BitmapDrawable defaults to the device's pixel density (unless you use a different constructor).

If you need to resize also then just separate it into two lines and use setBounds before converting the BitmapDrawable back to a bitmap like so:

<pre><code>BitmapDrawable bitmapDrawable = new BitmapDrawable(getResources(), yourBitmap);
bitmapDrawable.setBounds(left, top, right, bottom); //Make it a new size in pixels.
yourBitmap = bitmapDrawable.getBitmap(); //Convert it back to a bitmap optimised for display purposes.
</code></pre>

Bitmap drawable may be listed as depricated but it's not, only certain constructors are depricated and the constructor in this above example is not depricated. Also this will work with API 4

Alternativly the android docs have a downloadable sample for this here: <a href="https://developer.android.com/topic/performance/graphics/load-bitmap.html" rel="nofollow noreferrer">https://developer.android.com/topic/performance/graphics/load-bitmap.html</a>

Hope this helps.

Is there any way or external library that can resize image using Lanczos (ideally) or at least bicubic alg. under Android? (faster is better of course, but quality is priority, a processing time is secondary)

Everything what I've got so far is this:

<pre><code>Bitmap resized = Bitmap.createScaledBitmap(yourBitmap, newWidth, newHeight, true);
</code></pre>

However it uses bilinear filter and the output quality is terrible. Especially if you want to preserve details (like thin lines or readable texts).

There are many good libraries for Java as discussed for example here:
<a href="https://stackoverflow.com/questions/24745147/java-resize-image-without-losing-quality">Java - resize image without losing quality</a>

However it's always depended on Java awt classes like <code>java.awt.image.BufferedImage</code>, so it can't be used in Android.

Is there a way how to change the default (bilinear) filter in <code>Bitmap.createScaledBitmap()</code> method or some library like <a href="https://github.com/mortennobel/java-image-scaling" rel="noreferrer">Morten Nobel's lib</a> that is able to work with <code>android.graphics.Bitmap</code> class (or with some raw representation, as @Tron in the comment has pointed out)?

Android: Bitmap resizing using better resampling algorithm than bilinear (like Lanczos3)

Android

Java

是否有任何方法或外部库可以使用Lanczos (理想情况下)或至少双三次alg来调整图像大小。在Android下？(当然，越快越好，但质量是第一位的，处理时间是第二位的)到目前为止，我得到的所有东西是：Bitmap resized = Bitmap.createScaledBitmap(yourBitmap, newW...

问安卓:使用比双线性(如Lanczos3)更好的重采样算法调整位图大小
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问安卓:使用比双线性(如Lanczos3)更好的重采样算法调整位图大小EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问安卓:使用比双线性(如Lanczos3)更好的重采样算法调整位图大小
EN