浅谈android中加载高清大图及图片压缩方式(二)

痛定思痛。 2022-07-24 06:02 124阅读 0赞

这一讲就是本系列的第二篇，一起来聊下关于android中加载高清大图的问题，我们都知道如果我们直接加载原图的话，一个是非常慢，需要等待一定时间，如果没有在一定的时间内给用户响应的话，将会极大影响用户的体验。另一个是如果你的手机内存小的话，可能会直接崩溃。这也就是直接加载高清原图问题。遇到这些问题很容易想到的一点就是图片压缩，本篇文章也就是讲述图片压缩方式来实现加载高清大图的效果。但是现在问题就来了，通过上篇博客我们知道，手机的分辨率有很多，如何保证我同一张图片在不同分辨率的手机上能适当的压缩比例显示出来呢？？？有的人就直接压缩小点，那么就可以在不同的多个分辨率的手机上显示出来。但是我们都知道压缩的越小，失真率就越高。很容易理解，大部分我们使用的都是位图，位图有一个特点就是有很多个像素点组成的像素矩阵，当我们压缩图片时就相当于像素点，本来显示这张图片需要７２０＊１２８０个像素点，现在压缩成３２０＊４８０个像素点，这么少的像素点不足以显示出原来的效果，最后明显造成图片显示不清楚。所以找到一个合适的压缩比例就显得尤为重要了。

那我们如何做呢?实现的大致思路如下:我们所谓的压缩实际上就是去设置BItmap中的一个inSampleSize(采样率)属性，通过它实现图片的压缩。怎么样去给inSampleSize属性设置一个合适的值呢??首先因为屏幕的分辨率多样化，然后我的图片要根据不同分辨率来得到不同inSampleSize，这样才会合适显示在我的手机屏幕上。所以需要获得屏幕的高度和宽度，然后再去拿到屏幕高度和宽度。然后用图片的宽度，高度分别去除以屏幕的高度和宽度，最后就得到高度比例和宽度比例。

到这里就会出现两种方法来实现压缩：一种比较繁琐，另一种更直接。

首先，说第一种压缩方式吧。

由于图片大多数都是位图显示，即具体个数的像素点来显示的，在不同分辨率的手机屏幕显示图片说白就是在不同像素点的总数的屏幕中显示，很容易理解，当我有个很大的图片，所谓很很大的图片 就是总的像素点数很多，并且在低分辨（总的像素点少显示）肯定有问题，只能显示部分，所以需要 根据当前的手机分辨率的大小，来适当压缩图片的大小比例，然后来显示在相应分辨率的屏幕上当我通过某个方式拿到一张图片会有如下几种情况: 图片宽度（ImWidth）,图片高度(ImHeight),屏幕宽度(Width),屏幕高度(Height)  
  
　　　　　　1、若图片的宽度大于图片高度（即横向图片）,且宽度大于屏幕宽度：Size=ImWidth/Width  
　　　　　　2、若图片的高度大于图片宽度(即纵向图片)，且高度大于屏幕高度:Size=ImHeight/Height;  
　　　　　　3、就是根据一个图片压缩比例算法公式：取图片宽度压缩倍数和图片高度的压缩倍数的平均值:Size=(ImWidth/Width+ImHeight/Height)/2;

最后将我们在不同情况下得到的size赋给我们的inSampleSize。

然后，说第二种，第二种就更直接暴力，直接给出一个公式:

inSampleSize=Math.sqrt(widthScaleSize\*widthScaleSize+heightScaleSize\*heightScaleSize);

这个公式有点像数学上的勾股定理，但是自己想想挺有道理，它这样取这么一个inSampleSize，其实类似就是去对角线的压缩比。

最后再来说一种方式，这个叫图片质量的压缩，就是在我们压缩图片过程，如何尽量保证我们的图片的质量呢？？主要是通过Bitmap的compress来实现

质量的压缩的。不妨我们来看下源码是怎么介绍的吧。

/\*\*  
\* Write a compressed version of the bitmap to the specified outputstream.  
\* If this returns true, the bitmap can be reconstructed by passing a  
\* corresponding inputstream to BitmapFactory.decodeStream(). Note: not  
\* all Formats support all bitmap configs directly, so it is possible that  
\* the returned bitmap from BitmapFactory could be in a different bitdepth,  
\* and/or may have lost per-pixel alpha (e.g. JPEG only supports opaque  
\* pixels).  
\*  
\* @param format The format of the compressed image  
\* @param quality Hint to the compressor, 0-100. 0 meaning compress for  
\* small size, 100 meaning compress for max quality. Some  
\* formats, like PNG which is lossless, will ignore the  
\* quality setting  
\* @param stream The outputstream to write the compressed data.  
\* @return true if successfully compressed to the specified stream.  
\*/

bitmap.compress(Bitmap.CompressFormat.PNG, 100, baos)

它大致的意思是这样的就是将一个Bitmap对象保存在一个确定的输出流中，并且compress会返回一个boolean类型的值，如果返回为true

就会通过一个与之相对应的输入流来重建一个BItmap对象，然后标注了:并不是所有的格式都直接支持这种方式，这样就会造成出来不同尺寸大小BItmap可能

会失去原有图片像素的透明度。力例如JPEG格式图片仅仅支持不透明像素点。还需要注意：就是里面quality参数的介绍：它是这样说的quatily取值范围为:0到100

0代表质量最低，１００则代表质量最高，如果是PNG格式的图片的话，忽视了质量值的设置，就会造成图片的失真。

那么有了以上的了解，相信对下面代码的理解更加简单了。

package com.mikyou.loadBigImage;
    
    import java.io.ByteArrayInputStream;
    import java.io.ByteArrayOutputStream;
    import java.io.IOException;
    
    import android.app.Activity;
    import android.graphics.Bitmap;
    import android.graphics.BitmapFactory;
    import android.media.ExifInterface;
    import android.os.Bundle;
    import android.os.Environment;
    import android.util.DisplayMetrics;
    import android.view.View;
    import android.widget.ImageView;
    
    public class MainActivity extends Activity {
    	  private ImageView bigIv;
    	    private int Width, Height, ImWidth, ImHeight;//获取屏幕的高度和宽度以及图片的高度和宽度
    
    	    @Override
    	    protected void onCreate(Bundle savedInstanceState) {
    	        super.onCreate(savedInstanceState);
    	        setContentView(R.layout.activity_main);
    	        getScreenWidthAndHeight();
    	        bigIv = (ImageView) findViewById(R.id.big_iv);
    	    }
    
    	    public void loadBigImage(View view) {
    	        //读取SD卡的状态，并且-判断SD卡是否可用
    	        if (Environment.getExternalStorageState().equals(Environment.MEDIA_MOUNTED)) {
    	            //先判断SD卡的状态是否可用，mnt目录shell--->emualted---->0
    	            //如果是可用的状态，就读到SD卡的路径，然后将它加载出来
    	            //如果图片过大就容易造成图片加载的延迟甚至会造成内存溢出，所以需要对图片做一定的压缩处理
    	            BitmapFactory.Options options = new BitmapFactory.Options();
    	           String path = Environment.getExternalStorageDirectory() + "/img_big_1.jpg";
    	            /**
    	             * 思考：如何合理设置inSampleSize来针对不同分辨率的手机，从而得到一个更佳的图片压缩方案呢？？
    	             * 分析：
    	             * 由于图片大多数都是位图显示，即具体个数的像素点来显示的，在不同分辨率的手机屏幕显示图片
    	             * 说白就是在不同像素点的总数的屏幕中显示，很容易理解，当我有个很大的图片，所谓很很大的图片
    	             * 就是总的像素点数很多，并且在低分辨（总的像素点少显示）肯定有问题，只能显示部分，所以需要
    	             * 根据当前的手机分辨率的大小，来适当压缩图片的大小比例，然后来显示在相应分辨率的屏幕上
    	             * 当我通过某个方式拿到一张图片会有如下几种情况:
    	             *       图片宽度（ImWidth）,图片高度(ImHeight),屏幕宽度(Width),屏幕高度(Height)
    	             *       一、根据SD卡路径加载图片的大小比例压缩
    	             *              1、若图片的宽度大于图片高度（即横向图片）,且宽度大于屏幕宽度：Size=ImWidth/Width
    	             *              2、若图片的高度大于图片宽度(即纵向图片)，且高度大于屏幕高度:Size=ImHeight/Height;
    	             *              3、就是根据一个图片压缩比例算法公式：取图片宽度压缩倍数和图片高度的压缩倍数的平均值:Size=(ImWidth/Width+ImHeight/Height)/2;
    	             *       二、图片的质量的压缩
    	             *       三、根据Bitmap来压缩图片大小比例
    	             * */
    	            //bitmap=getImageCompress(bitmap);
    	           // bitmap= getImageByScaleSize(bitmap);
    	           Bitmap bitmap=getImageByScaleSizeByTec(path);
    	            bigIv.setImageBitmap(bitmap);
    	        }
    	    }
    	    /**
    	     * 图片的质量压缩:
    	     * 图片质量的压缩思想大致如下:
    	     * 先将一张图片到一个字节数组输出流对象保存，
    	     * 然后通过不断压缩数据，直到图片大小压缩到某个具体大小时，然后再把
    	     * 字节数组输出流对象作为一个字节数组输入流参数对象传入得到一个字节数组输入流
    	     * 最后再将字节数组输入流得到Bitmap对象，最终拿到图片质量压缩后的图片
    	     */
    	    public Bitmap getImageCompress(Bitmap bitmap) {
    	        ByteArrayOutputStream baos = new ByteArrayOutputStream();
    	        bitmap.compress(Bitmap.CompressFormat.PNG, 100, baos);//质量压缩方法，这里100表示不压缩，把压缩后的数据存放到字节数组输出流中。
    	        int options = 100;
    	        while (baos.toByteArray().length / 1024 > 100) {    //循环判断如果压缩后图片是否大于100kb,大于继续压缩
    	            baos.reset();//重置baos即清空baos
    	            options -= 10;//每次都减少10
    	            bitmap.compress(Bitmap.CompressFormat.JPEG, options, baos);//这里压缩options%，把压缩后的数据存放到baos中
    	        }
    	        ByteArrayInputStream isBm = new ByteArrayInputStream(baos.toByteArray());//把压缩后的数据baos存放到ByteArrayInputStream中
    	        Bitmap bitmap2 = BitmapFactory.decodeStream(isBm, null, null);//把ByteArrayInputStream数据生成图片
    	        return bitmap2;
    	    }
    
    	    /**
    	     * 根据SD卡路径加载图片的大小比例压缩
    	     */
    	    public Bitmap getImageByScaleSize(String path) {
    	        int scaleSize =1;//1就表示不压缩
    	        BitmapFactory.Options options = new BitmapFactory.Options();
    	 /*       options.inJustDecodeBounds=true;//只读取图片的信息，不读取图片的具体数据
    	        ImWidth = options.outWidth;
    	        ImHeight = options.outHeight;*/
    	        getImageWidthAndHeight(path);//得到图片的高度和宽度
    	        if (ImWidth > ImHeight && ImWidth > Width) {
    	            scaleSize = (int)(ImWidth*1.0f / Width+0.5f);//加0.5是为了四舍五入，取一个很好的精度
    	        } else if (ImHeight > ImWidth && ImHeight > Height) {
    	            scaleSize = (int)(ImHeight*1.0f / Height+0.5f);
    	        } else {//其他情况表示，就是当是横向或者纵向图片时，它的长度和宽度都大于屏幕
    	            scaleSize = (int)(ImWidth*1.0f / Width + ImHeight*1.0f / Height+0.5f) / 2;
    	        }ba
    	        //设置图片的采样率
    	        options.inSampleSize = scaleSize;//针对不同的手机分辨率，设置的缩放比也不一样，这里的值可能是不一样的
    	        Bitmap bitmap2 = BitmapFactory.decodeFile(path, options);
    	              return bitmap2;
    	    }
    	    //获取当前手机屏幕的高度和宽度
    	    private void getScreenWidthAndHeight() {
    	        DisplayMetrics metrics = new DisplayMetrics();
    	        getWindowManager().getDefaultDisplay().getMetrics(metrics);
    	        Width = metrics.widthPixels;
    	        Height = metrics.heightPixels;
    	    }
    	     //得到原图的高度和宽度
    	    private void getImageWidthAndHeight(String path) {
    	        try {
    	            ExifInterface exifInterfece=new ExifInterface(path);
    	            ImWidth=exifInterfece.getAttributeInt(ExifInterface.TAG_IMAGE_WIDTH,0);
    	            ImHeight=exifInterfece.getAttributeInt(ExifInterface.TAG_IMAGE_LENGTH,0);
    	        } catch (IOException e) {
    	            e.printStackTrace();
    	        }
    	    }
    	    /**
    	     * 公式法
    	     * */
    	    public Bitmap getImageByScaleSizeByTec(String path){
    	        int scaleSize =1;//1就表示不压缩
    	        getImageWidthAndHeight(path);
    	        int WidthScaleSize=(int)(ImWidth*1.0f/Width*1.0f+0.5f);
    	        int HeightScaleSize=(int)(ImHeight*1.0f/Height*1.0f+0.5f);
    	        scaleSize=(int)(Math.sqrt(WidthScaleSize*WidthScaleSize+HeightScaleSize*HeightScaleSize)+0.5f);
    	        BitmapFactory.Options options = new BitmapFactory.Options();
    	        //设置图片的采样率
    	        options.inSampleSize = scaleSize;//针对不同的手机分辨率，设置的缩放比也不一样，这里的值可能是不一样的
    	        Bitmap bitmap = BitmapFactory.decodeFile(path, options);
    	        return bitmap;
    	    }
    
    }

运行结果:

![Center][]

[Center]: /images/20220722/20b379b2c74045658efe0428bb33579a.png