我在文件中有一个大的位图(例如3888x2592)。现在,我想将该位图的大小调整为800x533并将其保存到另一个文件中。
我通常会通过调用Bitmap.createBitmap方法缩放位图,但是它需要一个源位图作为第一个参数,由于加载,我无法提供它放入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参数。话虽这么说,但我和您有同样的问题,而且我对两步法也不是很满意。

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

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

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

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

#1 楼

否。我希望有人能纠正我,但我接受了您尝试权衡的加载/调整大小方法。

以下是任何浏览的步骤:


计算最大可能的inSampleSize仍会生成比目标大的图像。
使用BitmapFactory.decodeFile(file, options)加载图像,将inSampleSize作为选项。
使用Bitmap.createScaledBitmap()将尺寸调整为所需尺寸。
>

评论


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

– Manuel
2010年7月26日在9:08

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

–贾斯汀
2010年7月26日在12:18

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

– Manuel
2010年7月26日在19:01

正如PSIXO在回答中提到的那样,如果在使用inSampleSize之后仍然有问题,您可能还想使用android:largeHeap。

–user276648
15年3月17日在2:45

位图变量变空

– Prasad
18 Mar 16 '18在8:57

#2 楼

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

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


评论


使用“ b”之类的变量时,很难阅读,但答案仍然不错。

–奥利弗·迪克森(Oliver Dixon)
2012年8月14日上午10:05

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

– Biginner
13年5月28日在8:21

代替(wh)/Math.pow(scale,2),使用(wh)>> scale更有效。

– david.perez
2014年9月23日下午13:12

请不要调用System.gc()

– gw0
2015年4月11日14:24在

谢谢@Ofir,但是这种转换不能保存图像方向:-/

–JoeCoolman
15年9月24日在5:22

#3 楼

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


它仅读取元数据以获取原始大小(options.inJustDecodeBounds)
它使用粗略调整大小来节省内存(itmap.createScaledBitmap)
它使用基于先前创建的粗略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);
}


#4 楼

为什么不使用API​​?

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


评论


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

– Manuel
2010-09-5 20:46



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

– Bostone
10-9-6'2:16



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

– Hamza
17-10-24在9:28

#5 楼

到目前为止,还有其他出色的答案,我见过的最好的代码是在摄影工具的文档中。

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

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


评论


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

–cybergen
16年3月15日在22:11

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

–cybergen
16 Mar 15 '16 at 23:33

#6 楼

阅读完这些答案和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;不推荐使用。

– Ravit
16年6月6日在11:56

#7 楼

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

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);


评论


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

– Manuel
2010年7月26日19:00

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

– RRTW
2011年12月1日的2:01

#8 楼

这对于其他正在看这个问题的人可能很有用。我重写了Justin的代码,以允许该方法也接收所需的目标大小对象。使用Canvas时,效果很好。

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


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

#9 楼

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

变量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;


评论


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

–Ostkontentitan
2014年11月27日12:16

#10 楼

考虑到您想调整大小到准确的大小并希望保持所需的质量,我认为您应该尝试一下。


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

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

注意:如果在步骤3中加载的位图至少是4倍较大(因此4 * targetWidth 至少在通用Java中有效,在android中您无法选择用于缩放的插值
http://today.java.net/pub/a/today/2007/ 04/03 / perils-of-image-getscaledinstance.html

#11 楼

我使用了这样的代码:

  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。 />

#12 楼

上面的代码使代码更加简洁。 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");

    }


#13 楼

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

考虑到所涉及的复杂性,使用两步子采样,然后重新缩放可能最适合于图片-预览类型的应用。

#14 楼

这是一篇采用不同方法调整大小的文章。它将尝试根据进程中的可用内存将最大可能的位图加载到内存中,然后执行转换。

http://bricolsoftconsulting.com/2012/12/07/handling-large- Android上的图片/

#15 楼

如果您绝对想进行一步调整大小,如果

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

#16 楼

Android开发者网站上有一篇有关此确切问题的好文章:
有效地加载大位图

#17 楼

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

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

}


#18 楼

这是我使用的代码,在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页面上使用计算即可。

–法蒂
14年8月19日在19:15

#19 楼

 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);


#20 楼

我使用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)
}


#21 楼

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

    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