在Android上调整大位图文件的大小以缩放输出文件


218

我在文件中有一个大的位图(例如3888x2592)。现在,我想将该位图的大小调整为800x533并将其保存到另一个文件中。我通常会通过调用Bitmap.createBitmapmethod 来缩放位图,但是它需要源位图作为第一个参数,我无法提供,因为将原始图像加载到Bitmap对象中当然会超出内存(例如,请参见此处)。

我也无法读取与位图,例如BitmapFactory.decodeFile(file, options),提供了BitmapFactory.Options.inSampleSize,因为我想将它调整到一个确切的宽度和高度。使用inSampleSize会将位图的大小调整为972x648(如果使用inSampleSize=4)或778x518(如果使用inSampleSize=5,则甚至不是2的幂)。

我还想避免在第一步中使用inSampleSize读取图像,例如,在972x648上读取图像,然后在第二步中将其尺寸调整为恰好为800x533,因为与直接调整原始图像的尺寸相比,其质量很差。

总结一下我的问题:是否可以读取10MP或更大的大图像文件并将其保存到新的图像文件中,并调整大小为特定的新宽度和高度,而不会出现OutOfMemory异常?

我还尝试BitmapFactory.decodeFile(file, options)将Options.outHeight和Options.outWidth值手动设置为800和533,但这种方式不起作用。


不,outHeight和outWidth是来自解码方法的out参数。话虽这么说,但我和您有同样的问题,而且我对两步法也不是很满意。
rds 2010年

通常,谢天谢地,您可以使用一行代码.. stackoverflow.com/a/17733530/294884
Fattie 2014年

读者,请注意此绝对关键的质量检查! stackoverflow.com/a/24135522/294884
Fattie 2014年

1
请注意,这个问题已有5年历史了,完整的解决方案是.. stackoverflow.com/a/24135522/294884干杯!
Fattie

2
现在有关于该主题的官方文档:developer.android.com/training/displaying-bitmaps/…–
Vince

Answers:


146

不, 我希望有人纠正我,但我接受了您尝试让您妥协的加载/调整大小方法。

这是任何浏览的步骤:

  1. 计算最大可能 inSampleSize仍产生比目标大的图像。
  2. 使用加载图像BitmapFactory.decodeFile(file, options),并传入inSampleSize作为选项。
  3. 使用调整大小到所需的尺寸Bitmap.createScaledBitmap()

我试图避免这种情况。因此,仅一步之遥就无法直接调整大图像的大小吗?
曼努埃尔

2
据我所知,但不要让您阻止对此进行进一步的研究。
贾斯汀

好吧,到目前为止,我将以此为我接受的答案。如果我发现其他方法,将通知您。
曼努埃尔

作为PSIXO在回答中提到的,你可能想使用Android:largeHeap如果你仍然在使用inSampleSize后的问题。
user276648

位图变量变空了
Prasad

99

贾斯汀答案翻译成代码(对我来说很完美):

private Bitmap getBitmap(String path) {

Uri uri = getImageUri(path);
InputStream in = null;
try {
    final int IMAGE_MAX_SIZE = 1200000; // 1.2MP
    in = mContentResolver.openInputStream(uri);

    // Decode image size
    BitmapFactory.Options options = new BitmapFactory.Options();
    options.inJustDecodeBounds = true;
    BitmapFactory.decodeStream(in, null, options);
    in.close();



    int scale = 1;
    while ((options.outWidth * options.outHeight) * (1 / Math.pow(scale, 2)) > 
          IMAGE_MAX_SIZE) {
       scale++;
    }
    Log.d(TAG, "scale = " + scale + ", orig-width: " + options.outWidth + ", 
       orig-height: " + options.outHeight);

    Bitmap resultBitmap = null;
    in = mContentResolver.openInputStream(uri);
    if (scale > 1) {
        scale--;
        // scale to max possible inSampleSize that still yields an image
        // larger than target
        options = new BitmapFactory.Options();
        options.inSampleSize = scale;
        resultBitmap = BitmapFactory.decodeStream(in, null, options);

        // resize to desired dimensions
        int height = resultBitmap.getHeight();
        int width = resultBitmap.getWidth();
        Log.d(TAG, "1th scale operation dimenions - width: " + width + ",
           height: " + height);

        double y = Math.sqrt(IMAGE_MAX_SIZE
                / (((double) width) / height));
        double x = (y / height) * width;

        Bitmap scaledBitmap = Bitmap.createScaledBitmap(resultBitmap, (int) x, 
           (int) y, true);
        resultBitmap.recycle();
        resultBitmap = scaledBitmap;

        System.gc();
    } else {
        resultBitmap = BitmapFactory.decodeStream(in);
    }
    in.close();

    Log.d(TAG, "bitmap size - width: " +resultBitmap.getWidth() + ", height: " + 
       resultBitmap.getHeight());
    return resultBitmap;
} catch (IOException e) {
    Log.e(TAG, e.getMessage(),e);
    return null;
}

15
使用“ b”之类的变量时,很难阅读,但答案仍然不错。
奥利弗·迪克森

@Ofir:getImageUri(路径); 我必须通过这种方法通过什么?
Biginner

1
代替(w h)/Math.pow(scale,2),使用(w h)>> scale 更有效
david.perez 2014年

2
System.gc()请不要致电
gw0

感谢@Ofir,但是这种转换不能保留图像的方向:-/
JoeCoolman 2015年

43

这是“ Mojo Risin”和“ Ofir”的解决方案“组合”。这将为您提供按比例调整大小的图像,并具有最大宽度和最大高度的边界。

  1. 它仅读取元数据以获取原始大小(options.inJustDecodeBounds)
  2. 它使用粗体大小调整来节省内存(itmap.createScaledBitmap)
  3. 它使用基于之前创建的粗略Bitamp的精确调整大小的图像。

对我来说,它在下面的5个MegaPixel图像上表现良好。

try
{
    int inWidth = 0;
    int inHeight = 0;

    InputStream in = new FileInputStream(pathOfInputImage);

    // decode image size (decode metadata only, not the whole image)
    BitmapFactory.Options options = new BitmapFactory.Options();
    options.inJustDecodeBounds = true;
    BitmapFactory.decodeStream(in, null, options);
    in.close();
    in = null;

    // save width and height
    inWidth = options.outWidth;
    inHeight = options.outHeight;

    // decode full image pre-resized
    in = new FileInputStream(pathOfInputImage);
    options = new BitmapFactory.Options();
    // calc rought re-size (this is no exact resize)
    options.inSampleSize = Math.max(inWidth/dstWidth, inHeight/dstHeight);
    // decode full image
    Bitmap roughBitmap = BitmapFactory.decodeStream(in, null, options);

    // calc exact destination size
    Matrix m = new Matrix();
    RectF inRect = new RectF(0, 0, roughBitmap.getWidth(), roughBitmap.getHeight());
    RectF outRect = new RectF(0, 0, dstWidth, dstHeight);
    m.setRectToRect(inRect, outRect, Matrix.ScaleToFit.CENTER);
    float[] values = new float[9];
    m.getValues(values);

    // resize bitmap
    Bitmap resizedBitmap = Bitmap.createScaledBitmap(roughBitmap, (int) (roughBitmap.getWidth() * values[0]), (int) (roughBitmap.getHeight() * values[4]), true);

    // save image
    try
    {
        FileOutputStream out = new FileOutputStream(pathOfOutputImage);
        resizedBitmap.compress(Bitmap.CompressFormat.JPEG, 80, out);
    }
    catch (Exception e)
    {
        Log.e("Image", e.getMessage(), e);
    }
}
catch (IOException e)
{
    Log.e("Image", e.getMessage(), e);
}

23

为什么不使用API​​?

int h = 48; // height in pixels
int w = 48; // width in pixels    
Bitmap scaled = Bitmap.createScaledBitmap(largeBitmap, w, h, true);

21
因为它不能解决我的问题。这就是:“ ...它需要源位图作为第一个参数,我无法提供,因为将原始图像加载到位图对象中当然会超出内存。” 因此,我也不能将位图传递给.createScaledBitmap方法,因为我仍然需要先将大图像加载到Bitmap对象中。
曼努埃尔

2
对。我重新阅读了您的问题,并且基本上(如果我理解正确的话)可以归结为“我可以在不将原始文件加载到内存的情况下将图像调整为确切的尺寸吗?” 如果是这样-我对图像处理的复杂性还不够了解,但是我从中得知1.它在API中不可用; 2。它不是1-liner。我会将其标记为收藏夹-看看您(或其他人)是否可以解决此问题将很有趣。
波士顿

它确实对我有用,因为我正在获取uri并转换为位图,因此对于我来说,最简单的缩放比例对我来说是1+。
Hamza

22

到目前为止,还知道了另一个很好的答案,为此,我看到的最好的代码是在拍照工具的文档中。

请参阅标题为“解码缩放的图像”的部分。

http://developer.android.com/training/camera/photobasics.html

它提出的解决方案是像此处其他解决方案一样先调整大小然后缩放解决方案,但这很简洁。

为了方便起见,我将以下代码复制为现成的功能。

private void setPic(String imagePath, ImageView destination) {
    int targetW = destination.getWidth();
    int targetH = destination.getHeight();
    // Get the dimensions of the bitmap
    BitmapFactory.Options bmOptions = new BitmapFactory.Options();
    bmOptions.inJustDecodeBounds = true;
    BitmapFactory.decodeFile(imagePath, bmOptions);
    int photoW = bmOptions.outWidth;
    int photoH = bmOptions.outHeight;

    // Determine how much to scale down the image
    int scaleFactor = Math.min(photoW/targetW, photoH/targetH);

    // Decode the image file into a Bitmap sized to fill the View
    bmOptions.inJustDecodeBounds = false;
    bmOptions.inSampleSize = scaleFactor;
    bmOptions.inPurgeable = true;

    Bitmap bitmap = BitmapFactory.decodeFile(imagePath, bmOptions);
    destination.setImageBitmap(bitmap);
}

1
首先,您要为整数指定底限。其次,代码崩溃,targetW或targetH为0(尽管我知道这没有多大意义)。第三inSampleSize应该是2的幂
。– cybergen

不要误会我的意思。这肯定会加载图像,但如果打算对int进行铺底,则看起来并非如此。而且这绝对不是正确的答案,因为图像将无法按预期缩放。除非图像视图的大小为图像的一半或更小,否则它将不会执行任何操作。然后,直到图像视图为图像大小的1/4为止,什么都不会发生。依此类推,具有两个幂!
cybergen '16

18

阅读完这些答案和android文档后,下面是代码来调整位图的大小而不将其加载到内存中:

public Bitmap getResizedBitmap(int targetW, int targetH,  String imagePath) {

    // Get the dimensions of the bitmap
    BitmapFactory.Options bmOptions = new BitmapFactory.Options();
    //inJustDecodeBounds = true <-- will not load the bitmap into memory
    bmOptions.inJustDecodeBounds = true;
    BitmapFactory.decodeFile(imagePath, bmOptions);
    int photoW = bmOptions.outWidth;
    int photoH = bmOptions.outHeight;

    // Determine how much to scale down the image
    int scaleFactor = Math.min(photoW/targetW, photoH/targetH);

    // Decode the image file into a Bitmap sized to fill the View
    bmOptions.inJustDecodeBounds = false;
    bmOptions.inSampleSize = scaleFactor;
    bmOptions.inPurgeable = true;

    Bitmap bitmap = BitmapFactory.decodeFile(imagePath, bmOptions);
    return(bitmap);
}

请注意,bmOptions.inPurgeable = true; 不推荐使用。
拉维特

6

当我有大位图并且想要解码它们的大小时,请使用以下内容

BitmapFactory.Options options = new BitmapFactory.Options();
InputStream is = null;
is = new FileInputStream(path_to_file);
BitmapFactory.decodeStream(is,null,options);
is.close();
is = new FileInputStream(path_to_file);
// here w and h are the desired width and height
options.inSampleSize = Math.max(options.outWidth/w, options.outHeight/h);
// bitmap is the resized bitmap
Bitmap bitmap = BitmapFactory.decodeStream(is,null,options);

1
由于inSampleSize是一个整数,因此很少会得到您想要获得的确切像素宽度和高度。有时您可能会靠近,但也可能离它很远,具体取决于小数位。
曼努埃尔2010年

早上,我确实尝试了您的代码(在此线程中发布),但似乎无法正常工作,我在哪里做错了?任何建议都欢迎:-)
RRTW 2011年

5

这对于其他正在看这个问题的人可能很有用。我重写了Justin的代码,以允许该方法也接收所需的目标大小对象。使用“画布”时,此方法效果很好。所有的功劳应该归功于JUSTIN出色的初始代码。

    private Bitmap getBitmap(int path, Canvas canvas) {

        Resources resource = null;
        try {
            final int IMAGE_MAX_SIZE = 1200000; // 1.2MP
            resource = getResources();

            // Decode image size
            BitmapFactory.Options options = new BitmapFactory.Options();
            options.inJustDecodeBounds = true;
            BitmapFactory.decodeResource(resource, path, options);

            int scale = 1;
            while ((options.outWidth * options.outHeight) * (1 / Math.pow(scale, 2)) > 
                  IMAGE_MAX_SIZE) {
               scale++;
            }
            Log.d("TAG", "scale = " + scale + ", orig-width: " + options.outWidth + ", orig-height: " + options.outHeight);

            Bitmap pic = null;
            if (scale > 1) {
                scale--;
                // scale to max possible inSampleSize that still yields an image
                // larger than target
                options = new BitmapFactory.Options();
                options.inSampleSize = scale;
                pic = BitmapFactory.decodeResource(resource, path, options);

                // resize to desired dimensions
                int height = canvas.getHeight();
                int width = canvas.getWidth();
                Log.d("TAG", "1th scale operation dimenions - width: " + width + ", height: " + height);

                double y = Math.sqrt(IMAGE_MAX_SIZE
                        / (((double) width) / height));
                double x = (y / height) * width;

                Bitmap scaledBitmap = Bitmap.createScaledBitmap(pic, (int) x, (int) y, true);
                pic.recycle();
                pic = scaledBitmap;

                System.gc();
            } else {
                pic = BitmapFactory.decodeResource(resource, path);
            }

            Log.d("TAG", "bitmap size - width: " +pic.getWidth() + ", height: " + pic.getHeight());
            return pic;
        } catch (Exception e) {
            Log.e("TAG", e.getMessage(),e);
            return null;
        }
    }

贾斯汀的代码在减少使用大型位图的开销方面非常有效。


4

我不知道我的解决方案是否是最佳实践,但是通过使用inDensityinTargetDensity选项,可以实现以所需缩放比例加载位图。最初inDensity0在不加载可绘制资源时使用的,因此此方法用于加载非资源图像。

变量imageUrimaxImageSideLengthcontext是我的方法的参数。为了清楚起见,我只发布了方法实现,而没有包装AsyncTask。

            ContentResolver resolver = context.getContentResolver();
            InputStream is;
            try {
                is = resolver.openInputStream(imageUri);
            } catch (FileNotFoundException e) {
                Log.e(TAG, "Image not found.", e);
                return null;
            }
            Options opts = new Options();
            opts.inJustDecodeBounds = true;
            BitmapFactory.decodeStream(is, null, opts);

            // scale the image
            float maxSideLength = maxImageSideLength;
            float scaleFactor = Math.min(maxSideLength / opts.outWidth, maxSideLength / opts.outHeight);
            // do not upscale!
            if (scaleFactor < 1) {
                opts.inDensity = 10000;
                opts.inTargetDensity = (int) ((float) opts.inDensity * scaleFactor);
            }
            opts.inJustDecodeBounds = false;

            try {
                is.close();
            } catch (IOException e) {
                // ignore
            }
            try {
                is = resolver.openInputStream(imageUri);
            } catch (FileNotFoundException e) {
                Log.e(TAG, "Image not found.", e);
                return null;
            }
            Bitmap bitmap = BitmapFactory.decodeStream(is, null, opts);
            try {
                is.close();
            } catch (IOException e) {
                // ignore
            }

            return bitmap;

2
非常好!使用inDensity代替Bitmap.createScaledBitmap为我节省了很多内存堆。最好与inSamplesize结合使用。
Ostkontentitan 2014年

2

考虑到您希望将尺寸调整为确切的尺寸并希望保持所需的质量,我认为您应该尝试一下。

  1. 调用BitmapFactory.decodeFile找出调整大小后的图像大小,并提供checkSizeOptions.inJustDecodeBounds
  2. 计算您可以在设备上使用的inSampleSize 的最大可能值,以不超过内存。bitmapSizeInBytes = 2 *宽度*高度; 通常对于您的图片,inSampleSize = 2会很好,因为您只需要2 * 1944x1296)=4.8Mbб,这应该占用内存
  3. 使用具有inSampleSize的BitmapFactory.decodeFile加载位图
  4. 将位图缩放为确切大小。

动机:多步缩放可以为您提供更高质量的图片,但是不能保证它会比使用高inSampleSize更好。实际上,我认为您也可以使用inSampleSize(例如5(不是2的pow))在一个操作中进行直接缩放。或者只使用4,然后您可以在UI中使用该图像。如果您将其发送到服务器-则可以在服务器端将其缩放到确切大小,从而可以使用高级缩放技术。

注意:如果在步骤3中加载的位图至少大4倍(因此4 * targetWidth <width),则可能可以使用几种调整大小来获得更好的质量。至少在通用Java中有效,在android中,您没有选择指定用于缩放的插值 http://today.java.net/pub/a/today/2007/04/03/perils-of- image-getscaledinstance.html


2

我使用了这样的代码:

  String filePath=Environment.getExternalStorageDirectory()+"/test_image.jpg";
  BitmapFactory.Options options=new BitmapFactory.Options();
  InputStream is=new FileInputStream(filePath);
  BitmapFactory.decodeStream(is, null, options);
  is.close();
  is=new FileInputStream(filePath);
  // here w and h are the desired width and height
  options.inSampleSize=Math.max(options.outWidth/460, options.outHeight/288); //Max 460 x 288 is my desired...
  // bmp is the resized bitmap
  Bitmap bmp=BitmapFactory.decodeStream(is, null, options);
  is.close();
  Log.d(Constants.TAG, "Scaled bitmap bytes, "+bmp.getRowBytes()+", width:"+bmp.getWidth()+", height:"+bmp.getHeight());

我尝试的原始图像是1230 x 1230,并且位图显示是330 x330
。如果尝试2590 x 3849,我将得到OutOfMemoryError。

我跟踪了它,如果原始位图太大,它仍会在“ BitmapFactory.decodeStream(is,null,options);”行上抛出OutOfMemoryError。


2

上面的代码使代码更简洁。InputStreams最终具有结束包装,以确保它们也被关闭:

*注
:输入:InputStream是int w,int h
输出:位图

    try
    {

        final int inWidth;
        final int inHeight;

        final File tempFile = new File(temp, System.currentTimeMillis() + is.toString() + ".temp");

        {

            final FileOutputStream tempOut = new FileOutputStream(tempFile);

            StreamUtil.copyTo(is, tempOut);

            tempOut.close();

        }



        {

            final InputStream in = new FileInputStream(tempFile);
            final BitmapFactory.Options options = new BitmapFactory.Options();

            try {

                // decode image size (decode metadata only, not the whole image)
                options.inJustDecodeBounds = true;
                BitmapFactory.decodeStream(in, null, options);

            }
            finally {
                in.close();
            }

            // save width and height
            inWidth = options.outWidth;
            inHeight = options.outHeight;

        }

        final Bitmap roughBitmap;

        {

            // decode full image pre-resized
            final InputStream in = new FileInputStream(tempFile);

            try {

                final BitmapFactory.Options options = new BitmapFactory.Options();
                // calc rought re-size (this is no exact resize)
                options.inSampleSize = Math.max(inWidth/w, inHeight/h);
                // decode full image
                roughBitmap = BitmapFactory.decodeStream(in, null, options);

            }
            finally {
                in.close();
            }

            tempFile.delete();

        }

        float[] values = new float[9];

        {

            // calc exact destination size
            Matrix m = new Matrix();
            RectF inRect = new RectF(0, 0, roughBitmap.getWidth(), roughBitmap.getHeight());
            RectF outRect = new RectF(0, 0, w, h);
            m.setRectToRect(inRect, outRect, Matrix.ScaleToFit.CENTER);
            m.getValues(values);

        }

        // resize bitmap
        final Bitmap resizedBitmap = Bitmap.createScaledBitmap(roughBitmap, (int) (roughBitmap.getWidth() * values[0]), (int) (roughBitmap.getHeight() * values[4]), true);

        return resizedBitmap;

    }
    catch (IOException e) {

        logger.error("Error:" , e);
        throw new ResourceException("could not create bitmap");

    }

1

要以“正确”的方式缩放图像而又不跳过任何像素,则必须挂接到图像解码器中才能逐行执行降采样。Android(以及作为其基础的Skia库)不提供此类挂钩,因此您必须自己动手。假设您正在谈论jpeg图片,那么最好的选择是直接在C语言中使用libjpeg。

考虑到所涉及的复杂性,对于图像预览类型的应用程序,最好使用两步子采样然后重新缩放。



1

如果您绝对要进行一步调整大小,则可能在android:largeHeap = true的情况下加载整个位图,但是如您所见,这实际上不是明智的选择。

来自文档:android:largeHeap是否应使用大型Dalvik堆创建应用程序的进程。这适用于为应用程序创建的所有进程。它仅适用于加载到进程中的第一个应用程序。如果您使用共享用户ID允许多个应用程序使用一个进程,则它们都必须一致地使用此选项,否则它们将产生不可预测的结果。大多数应用程序不需要此,而应专注于减少整体内存使用量以提高性能。启用此功能也不能保证可用内存的固定增加,因为某些设备受其总可用内存的限制。



0

这对我有用。该函数获取sd卡上文件的路径,并以最大可显示大小返回位图。该代码来自Ofir,并做了一些更改,例如sd上的图像文件,而Ressource和witdth和heigth则是从Display Object获取的。

private Bitmap makeBitmap(String path) {

    try {
        final int IMAGE_MAX_SIZE = 1200000; // 1.2MP
        //resource = getResources();

        // Decode image size
        BitmapFactory.Options options = new BitmapFactory.Options();
        options.inJustDecodeBounds = true;
        BitmapFactory.decodeFile(path, options);

        int scale = 1;
        while ((options.outWidth * options.outHeight) * (1 / Math.pow(scale, 2)) >
                IMAGE_MAX_SIZE) {
            scale++;
        }
        Log.d("TAG", "scale = " + scale + ", orig-width: " + options.outWidth + ", orig-height: " + options.outHeight);

        Bitmap pic = null;
        if (scale > 1) {
            scale--;
            // scale to max possible inSampleSize that still yields an image
            // larger than target
            options = new BitmapFactory.Options();
            options.inSampleSize = scale;
            pic = BitmapFactory.decodeFile(path, options);

            // resize to desired dimensions

            Display display = getWindowManager().getDefaultDisplay();
            Point size = new Point();
            display.getSize(size);
            int width = size.y;
            int height = size.x;

            //int height = imageView.getHeight();
            //int width = imageView.getWidth();
            Log.d("TAG", "1th scale operation dimenions - width: " + width + ", height: " + height);

            double y = Math.sqrt(IMAGE_MAX_SIZE
                    / (((double) width) / height));
            double x = (y / height) * width;

            Bitmap scaledBitmap = Bitmap.createScaledBitmap(pic, (int) x, (int) y, true);
            pic.recycle();
            pic = scaledBitmap;

            System.gc();
        } else {
            pic = BitmapFactory.decodeFile(path);
        }

        Log.d("TAG", "bitmap size - width: " +pic.getWidth() + ", height: " + pic.getHeight());
        return pic;

    } catch (Exception e) {
        Log.e("TAG", e.getMessage(),e);
        return null;
    }

}

0

这是我使用的代码,在Android上解码内存中的大图像没有任何问题。只要输入参数在1024x1024左右,我就能解码大于20MB的图像。您可以将返回的位图保存到另一个文件。在此方法下面是另一种方法,我也使用该方法将图像缩放到新的位图。随意使用此代码。

/*****************************************************************************
 * public decode - decode the image into a Bitmap
 * 
 * @param xyDimension
 *            - The max XY Dimension before the image is scaled down - XY =
 *            1080x1080 and Image = 2000x2000 image will be scaled down to a
 *            value equal or less then set value.
 * @param bitmapConfig
 *            - Bitmap.Config Valid values = ( Bitmap.Config.ARGB_4444,
 *            Bitmap.Config.RGB_565, Bitmap.Config.ARGB_8888 )
 * 
 * @return Bitmap - Image - a value of "null" if there is an issue decoding
 *         image dimension
 * 
 * @throws FileNotFoundException
 *             - If the image has been removed while this operation is
 *             taking place
 */
public Bitmap decode( int xyDimension, Bitmap.Config bitmapConfig ) throws FileNotFoundException
{
    // The Bitmap to return given a Uri to a file
    Bitmap bitmap = null;
    File file = null;
    FileInputStream fis = null;
    InputStream in = null;

    // Try to decode the Uri
    try
    {
        // Initialize scale to no real scaling factor
        double scale = 1;

        // Get FileInputStream to get a FileDescriptor
        file = new File( this.imageUri.getPath() );

        fis = new FileInputStream( file );
        FileDescriptor fd = fis.getFD();

        // Get a BitmapFactory Options object
        BitmapFactory.Options o = new BitmapFactory.Options();

        // Decode only the image size
        o.inJustDecodeBounds = true;
        o.inPreferredConfig = bitmapConfig;

        // Decode to get Width & Height of image only
        BitmapFactory.decodeFileDescriptor( fd, null, o );
        BitmapFactory.decodeStream( null );

        if( o.outHeight > xyDimension || o.outWidth > xyDimension )
        {
            // Change the scale if the image is larger then desired image
            // max size
            scale = Math.pow( 2, (int) Math.round( Math.log( xyDimension / (double) Math.max( o.outHeight, o.outWidth ) ) / Math.log( 0.5 ) ) );
        }

        // Decode with inSampleSize scale will either be 1 or calculated value
        o.inJustDecodeBounds = false;
        o.inSampleSize = (int) scale;

        // Decode the Uri for real with the inSampleSize
        in = new BufferedInputStream( fis );
        bitmap = BitmapFactory.decodeStream( in, null, o );
    }
    catch( OutOfMemoryError e )
    {
        Log.e( DEBUG_TAG, "decode : OutOfMemoryError" );
        e.printStackTrace();
    }
    catch( NullPointerException e )
    {
        Log.e( DEBUG_TAG, "decode : NullPointerException" );
        e.printStackTrace();
    }
    catch( RuntimeException e )
    {
        Log.e( DEBUG_TAG, "decode : RuntimeException" );
        e.printStackTrace();
    }
    catch( FileNotFoundException e )
    {
        Log.e( DEBUG_TAG, "decode : FileNotFoundException" );
        e.printStackTrace();
    }
    catch( IOException e )
    {
        Log.e( DEBUG_TAG, "decode : IOException" );
        e.printStackTrace();
    }

    // Save memory
    file = null;
    fis = null;
    in = null;

    return bitmap;

} // decode

注意:除了上面的createScaledBitmap调用解码方法外,方法彼此无关。注意宽度和高度可能会与原始图像有所不同。

/*****************************************************************************
 * public createScaledBitmap - Creates a new bitmap, scaled from an existing
 * bitmap.
 * 
 * @param dstWidth
 *            - Scale the width to this dimension
 * @param dstHeight
 *            - Scale the height to this dimension
 * @param xyDimension
 *            - The max XY Dimension before the original image is scaled
 *            down - XY = 1080x1080 and Image = 2000x2000 image will be
 *            scaled down to a value equal or less then set value.
 * @param bitmapConfig
 *            - Bitmap.Config Valid values = ( Bitmap.Config.ARGB_4444,
 *            Bitmap.Config.RGB_565, Bitmap.Config.ARGB_8888 )
 * 
 * @return Bitmap - Image scaled - a value of "null" if there is an issue
 * 
 */
public Bitmap createScaledBitmap( int dstWidth, int dstHeight, int xyDimension, Bitmap.Config bitmapConfig )
{
    Bitmap scaledBitmap = null;

    try
    {
        Bitmap bitmap = this.decode( xyDimension, bitmapConfig );

        // Create an empty Bitmap which will contain the new scaled bitmap
        // This scaled bitmap should be the size we want to scale the
        // original bitmap too
        scaledBitmap = Bitmap.createBitmap( dstWidth, dstHeight, bitmapConfig );

        float ratioX = dstWidth / (float) bitmap.getWidth();
        float ratioY = dstHeight / (float) bitmap.getHeight();
        float middleX = dstWidth / 2.0f;
        float middleY = dstHeight / 2.0f;

        // Used to for scaling the image
        Matrix scaleMatrix = new Matrix();
        scaleMatrix.setScale( ratioX, ratioY, middleX, middleY );

        // Used to do the work of scaling
        Canvas canvas = new Canvas( scaledBitmap );
        canvas.setMatrix( scaleMatrix );
        canvas.drawBitmap( bitmap, middleX - bitmap.getWidth() / 2, middleY - bitmap.getHeight() / 2, new Paint( Paint.FILTER_BITMAP_FLAG ) );
    }
    catch( IllegalArgumentException e )
    {
        Log.e( DEBUG_TAG, "createScaledBitmap : IllegalArgumentException" );
        e.printStackTrace();
    }
    catch( NullPointerException e )
    {
        Log.e( DEBUG_TAG, "createScaledBitmap : NullPointerException" );
        e.printStackTrace();
    }
    catch( FileNotFoundException e )
    {
        Log.e( DEBUG_TAG, "createScaledBitmap : FileNotFoundException" );
        e.printStackTrace();
    }

    return scaledBitmap;
} // End createScaledBitmap

秤的功率计算在这里根本是错误的;只需在android doco页面上使用计算即可。
Fattie

0
 Bitmap yourBitmap;
 Bitmap resized = Bitmap.createScaledBitmap(yourBitmap, newWidth, newHeight, true);

要么:

 resized = Bitmap.createScaledBitmap(yourBitmap,(int)(yourBitmap.getWidth()*0.8), (int)(yourBitmap.getHeight()*0.8), true);

0

我用 Integer.numberOfLeadingZeros来计算最佳的样本量,获得更好的性能。

Kotlin中的完整代码:

@Throws(IOException::class)
fun File.decodeBitmap(options: BitmapFactory.Options): Bitmap? {
    return inputStream().use {
        BitmapFactory.decodeStream(it, null, options)
    }
}

@Throws(IOException::class)
fun File.decodeBitmapAtLeast(
        @androidx.annotation.IntRange(from = 1) width: Int,
        @androidx.annotation.IntRange(from = 1) height: Int
): Bitmap? {
    val options = BitmapFactory.Options()

    options.inJustDecodeBounds = true
    decodeBitmap(options)

    val ow = options.outWidth
    val oh = options.outHeight

    if (ow == -1 || oh == -1) return null

    val w = ow / width
    val h = oh / height

    if (w > 1 && h > 1) {
        val p = 31 - maxOf(Integer.numberOfLeadingZeros(w), Integer.numberOfLeadingZeros(h))
        options.inSampleSize = 1 shl maxOf(0, p)
    }
    options.inJustDecodeBounds = false
    return decodeBitmap(options)
}

-2

使用以下代码调整位图的大小

    public static Bitmap decodeFile(File file, int reqWidth, int reqHeight){

    // First decode with inJustDecodeBounds=true to check dimensions
    final BitmapFactory.Options options = new BitmapFactory.Options();
    options.inJustDecodeBounds = true;        
    BitmapFactory.decodeFile(file.getPath(), options);

    // Calculate inSampleSize
    options.inSampleSize = calculateInSampleSize(options, reqWidth, reqHeight);

    // Decode bitmap with inSampleSize set
    options.inJustDecodeBounds = false;
    return BitmapFactory.decodeFile(file.getPath(), options);
   }

    private 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;
   }    

在下面的技巧中也有相同的解释

http://www.codeproject.com/Tips/625810/Android-Image-Operations-Using-BitmapFactory

By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.