36、Android Bitmap 全面解析

Android Bitmap 全面解析(一)加载大尺寸图片

http://www.eoeandroid.com/thread-331669-1-1.html

Android Bitmap 全面解析(二)加载多张图片的缓存处理
http://www.eoeandroid.com/thread-332399-1-1.html

Android Bitmap 全面解析(三)开源图片框架分析1-UIL(上)
http://www.eoeandroid.com/thread-333220-1-1.html

Android Bitmap 全面解析(三)开源图片框架分析1-UIL(下)
http://www.eoeandroid.com/thread-333229-1-1.html

 

Android Bitmap 全面解析(三)开源图片框架分析2-ImageLoader和Volley

http://www.eoeandroid.com/thread-334315-1-1.html

 

Android Bitmap 全面解析(四)图片处理效果对比

http://www.eoeandroid.com/thread-334752-1-1.html

 

 

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical"
    tools:context=".MainActivity" >

    <LinearLayout
        android:layout_width="fill_parent"
        android:layout_height="wrap_content"
        android:orientation="horizontal" >
        <ImageView
            android:id="@+id/iv1"
            android:layout_width="150dp"
            android:layout_height="150dp" />
        <ImageView
            android:id="@+id/iv2"
            android:layout_width="150dp"
            android:layout_height="150dp"
            android:layout_marginLeft="20dp"
            android:scaleType="centerCrop" />
    </LinearLayout>

    <LinearLayout
        android:layout_marginTop="50dp"
        android:layout_width="fill_parent"
        android:layout_height="wrap_content"
        android:orientation="horizontal" >
        <ImageView
            android:id="@+id/iv3"
            android:layout_width="150dp"
            android:layout_height="150dp" />
        <ImageView
            android:id="@+id/iv4"
            android:layout_width="150dp"
            android:layout_height="150dp"
            android:layout_marginLeft="20dp"
            android:scaleType="centerCrop" />
    </LinearLayout>

</LinearLayout>

package com.example.bdimagescale;

import android.app.Activity;
import android.content.res.Resources;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.os.Bundle;
import android.view.Menu;
import android.widget.ImageView;

public class MainActivity extends Activity {
    
    private static final int FIT_INSIDE = 1;
    private static final int CROP = 2;

    private ImageView iv1;// 默认缩放类型,即FIT_INSIDE
    private ImageView iv2;// centerCrop缩放类型,即CROP
    private ImageView iv3;// 默认缩放类型,即FIT_INSIDE
    private ImageView iv4;// centerCrop缩放类型,即CROP

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        // // 10000以内随机宽高
        // for(int i=0; i<20; i++) {
        // int width = (int)(Math.random()*9000+1000);
        // int height = (int)(Math.random()*9000+1000);
        // test(width, height, 400, 200, 200, 200);
        // // compareInSampleSize(width, height, 400, 200);
        // }

        iv1 = (ImageView) findViewById(R.id.iv1);
        iv2 = (ImageView) findViewById(R.id.iv2);
        iv3 = (ImageView) findViewById(R.id.iv3);
        iv4 = (ImageView) findViewById(R.id.iv4);
        testLongImage();
        // testNormalImage();
    }

    @Override
    public boolean onCreateOptionsMenu(Menu menu) {
// Inflate the menu; this adds items to the action bar if it is present.
        getMenuInflater().inflate(R.menu.main, menu);
        return true;
    }

    // 数据对比
    public void test(int width, int height, int limitWidth, 
          int limitHeight,int viewWidth, int viewHeight) {
        System.out.println("原图宽高=" + width + ":" + height);
        System.out.println("限定宽高=" + limitWidth + ":" + limitHeight);
        System.out.println("控件大小=" + viewWidth + ":" + viewHeight);
        float densityOfINSIDE0 = calculateImagePxDensityOfINSIDE(
               limitWidth,limitHeight, viewWidth, viewHeight);
        System.out.println("默认即INDESE情况下目标像素密度为=" 
                    + densityOfINSIDE0);
        float densityOfCROP0 = calculateImagePxDensityOfCROP(limitWidth,
                limitHeight, viewWidth, viewHeight);
        System.out.println("CROP情况下目标像素密度为=" + densityOfCROP0);
        System.out.println("---------------------");

        int inSampleSize1 = calculateInSampleSize(
                 width, height, limitWidth,limitHeight);
        int imageWidth = width / inSampleSize1;
        int imageHeight = height / inSampleSize1;
        System.out.println("官方:对应缩放后图片大小=" 
                  + imageWidth + ":" + imageHeight);
        float densityOfINSIDE = calculateImagePxDensityOfINSIDE(
                 imageWidth,imageHeight, viewWidth, viewHeight);
        System.out.println("默认即INDESE情况下像素密度为=" 
                 + densityOfINSIDE);
        float densityOfCROP = calculateImagePxDensityOfCROP(imageWidth,
                imageHeight, viewWidth, viewHeight);
        System.out.println("CROP情况下像素密度为=" + densityOfCROP);
        System.out.println("---------------------");

        int reWidth = getResizedDimension(limitWidth, limitHeight, 
                width,height);
        int reHeight = getResizedDimension(limitHeight, limitWidth, 
                height,width);
        // System.out.println("处理后限定宽高="+reWidth+":"+reHeight);
        int inSampleSize2 = findBestSampleSize(width, height, reWidth, 
                reHeight);
        int imageWidth2 = width / inSampleSize2;
        int imageHeight2 = height / inSampleSize2;
        System.out.println("Volley:对应缩放后图片大小=" + imageWidth2 + ":"
                + imageHeight2);
        float densityOfINSIDE2 = calculateImagePxDensityOfINSIDE(
                imageWidth2,imageHeight2, viewWidth, viewHeight);
        System.out.println("默认即INDESE情况下像素密度为=" 
                + densityOfINSIDE2);
        float densityOfCROP2 = calculateImagePxDensityOfCROP(imageWidth2,
                imageHeight2, viewWidth, viewHeight);
        System.out.println("CROP情况下像素密度为=" + densityOfCROP2);
        System.out.println("---------------------");

        int inSampleSize3OfINSIDE = computeImageSampleSize(width, height,
                limitWidth, limitHeight, FIT_INSIDE, true);
        int imageWidthOfINSIDE = width / inSampleSize3OfINSIDE;
        int imageHeightOfINSIDE = height / inSampleSize3OfINSIDE;
        System.out.println("UIL FIT_INSIDE:对应缩放后图片大小=" + imageWidthOfINSIDE
                + ":" + imageHeightOfINSIDE);
        float densityOfINSIDE3 = calculateImagePxDensityOfINSIDE(
                imageWidthOfINSIDE, imageHeightOfINSIDE, viewWidth, viewHeight);
        System.out.println("默认即INDESE情况下像素密度为=" + densityOfINSIDE3);
        int inSampleSize3OfCROP = computeImageSampleSize(width, height,
                limitWidth, limitHeight, CROP, true);
        int imageWidthOfCROP = width / inSampleSize3OfCROP;
        int imageHeightOfCROP = height / inSampleSize3OfCROP;
        System.out.println("UIL CROP:对应缩放后图片大小=" + imageWidthOfCROP + ":"
                + imageHeightOfCROP);
        float densityOfCROP3 = calculateImagePxDensityOfCROP(imageWidthOfCROP,
                imageHeightOfCROP, viewWidth, viewHeight);
        System.out.println("CROP情况下像素密度为=" + densityOfCROP3);
        System.out.println("---------------------");

        System.out.println();
    }

    // inSampleSize对比
    public void compareInSampleSize(int imageWidth, int imageHeight,
            int reqWidth, int reqHeight) {
        System.out.println("原图片 " + imageWidth + ":" + imageHeight);
        System.out.print("官方 "
                + calculateInSampleSize(imageWidth, imageHeight, reqWidth,
                        reqHeight));
        System.out.print(" ... ");
        System.out.print("UIL "
                + computeImageSampleSize(imageWidth, imageHeight, reqWidth,
                        reqHeight, CROP, true));
        System.out.print(" ... ");
        System.out.print("Volley "
                + findBestSampleSize(imageWidth, imageHeight, reqWidth,
                        reqHeight));
        System.out.println();
        System.out.println();
    }

    public void testLongImage() {
        Bitmap vbitmap = decodeByVolley(getResources(), R.drawable.longimage,
                300, 300);
        // UIL框架中会自行判断处理viewScaleType,这里为了简单临时手写了
        Bitmap ubitmap_inside = decodeByUIL(getResources(),
                R.drawable.longimage, 300, 300, FIT_INSIDE);
        Bitmap ubitmap_crop = decodeByUIL(getResources(), R.drawable.longimage,
                300, 300, CROP);

        iv1.setImageBitmap(vbitmap);
        iv2.setImageBitmap(vbitmap);

        iv3.setImageBitmap(ubitmap_inside);
        iv4.setImageBitmap(ubitmap_crop);
    }

    public void testNormalImage() {
        Bitmap vbitmap = decodeByVolley(getResources(), R.drawable.normalimage,
                300, 300);
        // UIL框架中会自行判断处理viewScaleType,这里为了简单临时手写了
        Bitmap ubitmap_inside = decodeByUIL(getResources(),
                R.drawable.normalimage, 300, 300, FIT_INSIDE);
        Bitmap ubitmap_crop = decodeByUIL(getResources(),
                R.drawable.normalimage, 300, 300, CROP);

        iv1.setImageBitmap(vbitmap);
        iv2.setImageBitmap(vbitmap);

        iv3.setImageBitmap(ubitmap_inside);
        iv4.setImageBitmap(ubitmap_crop);
    }

    public Bitmap decodeByVolley(Resources res, int resId, int limitWidth,
            int limitHeight) {

        // 首先不加载图片,仅获取图片尺寸
        final BitmapFactory.Options options = new BitmapFactory.Options();
        // 当inJustDecodeBounds设为true时,不会加载图片仅获取图片尺寸信息
        options.inJustDecodeBounds = true;
        // 此时仅会将图片信息会保存至options对象内,decode方法不会返回bitmap对象
        BitmapFactory.decodeResource(res, resId, options);

        int reWidth = getResizedDimension(limitWidth, limitHeight,
                options.outWidth, options.outHeight);
        int reHeight = getResizedDimension(limitHeight, limitWidth,
                options.outHeight, options.outWidth);

        // 计算压缩比例,如inSampleSize=4时,图片会压缩成原图的1/4
        options.inSampleSize = findBestSampleSize(options.outWidth,
                options.outHeight, reWidth, reHeight);

        // 当inJustDecodeBounds设为false时,BitmapFactory.decode...就会返回图片对象了
        options.inJustDecodeBounds = false;
        // 利用计算的比例值获取压缩后的图片对象
        return BitmapFactory.decodeResource(res, resId, options);
    }

    public Bitmap decodeByUIL(Resources res, int resId, int limitWidth,
            int limitHeight, int scaleType) {

        // 首先不加载图片,仅获取图片尺寸
        final BitmapFactory.Options options = new BitmapFactory.Options();
        // 当inJustDecodeBounds设为true时,不会加载图片仅获取图片尺寸信息
        options.inJustDecodeBounds = true;
        // 此时仅会将图片信息会保存至options对象内,decode方法不会返回bitmap对象
        BitmapFactory.decodeResource(res, resId, options);

        // 计算压缩比例,如inSampleSize=4时,图片会压缩成原图的1/4
        options.inSampleSize = computeImageSampleSize(options.outWidth,
                options.outWidth, limitWidth, limitHeight, scaleType, true);

        // 当inJustDecodeBounds设为false时,BitmapFactory.decode...就会返回图片对象了
        options.inJustDecodeBounds = false;
        // 利用计算的比例值获取压缩后的图片对象
        return BitmapFactory.decodeResource(res, resId, options);
    }

    // 计算FIT_INSIDE时像素密度
    static float calculateImagePxDensityOfINSIDE(int imageWidth,
            int imageHeight, int viewWidth, int viewHeight) {
        float density = -1;
        if (imageWidth >= imageHeight) {
            density = (float) imageWidth / (float) viewWidth;
        } else {
            density = (float) imageHeight / (float) viewHeight;
        }
        return density * density;
    }

    // 计算CROP时像素密度
    static float calculateImagePxDensityOfCROP(int imageWidth, int imageHeight,
            int viewWidth, int viewHeight) {
        float density = -1;
        if (imageWidth >= imageHeight) {
            density = (float) imageHeight / (float) viewHeight;
        } else {
            density = (float) imageWidth / (float) viewWidth;
        }
        return density * density;
    }

    // ////////////////// 官方 ////////////////////////////////
    int calculateInSampleSize(int width, int height, int reqWidth, int reqHeight) {
        // 初始化压缩比例为1
        int inSampleSize = 1;

        // 当图片宽高值任何一个大于所需压缩图片宽高值时,进入循环计算系统
        if (height > reqHeight || width > reqWidth) {

            final int halfHeight = height / 2;
            final int halfWidth = width / 2;

            // 压缩比例值每次循环两倍增加,
            // 直到原图宽高值的一半除以压缩值后都~大于所需宽高值为止(将>改成了>=)
            while ((halfHeight / inSampleSize) >= reqHeight
                    && (halfWidth / inSampleSize) >= reqWidth) {
                inSampleSize *= 2;
            }
        }
        return inSampleSize;
    }

    // ////////////////// UIL ////////////////////////////////
    int computeImageSampleSize(int width, int height, int limitWidth,
            int limitHeight, int viewScaleType, boolean powerOf2Scale) {

        int scale = 1;

        int widthScale = width / limitWidth;
        int heightScale = height / limitHeight;

        switch (viewScaleType) {
        case FIT_INSIDE:
            if (powerOf2Scale) {
                while (width / 2 >= limitWidth || height / 2 >= limitHeight) { // ||
                    width /= 2;
                    height /= 2;
                    scale *= 2;
                }
            } else {
                scale = Math.max(widthScale, heightScale); // max
            }
            break;
        case CROP:
            if (powerOf2Scale) {
                while (width / 2 >= limitWidth && height / 2 >= limitHeight) { // &&
                    width /= 2;
                    height /= 2;
                    scale *= 2;
                }
            } else {
                scale = Math.min(widthScale, heightScale); // min
            }
            break;
        }

        if (scale < 1) {
            scale = 1;
        }

        return scale;
    }

    // ////////////////// Volley ////////////////////////////////
    int findBestSampleSize(int actualWidth, int actualHeight, int desiredWidth,
            int desiredHeight) {
        double wr = (double) actualWidth / desiredWidth;
        double hr = (double) actualHeight / desiredHeight;
        double ratio = Math.min(wr, hr);
        float n = 1.0f;
        while ((n * 2) <= ratio) {
            n *= 2;
        }

        return (int) n;
    }

    int getResizedDimension(int maxPrimary, int maxSecondary,
            int actualPrimary, int actualSecondary) {
        // If no dominant value at all, just return the actual.
        if (maxPrimary == 0 && maxSecondary == 0) {
            return actualPrimary;
        }

        // If primary is unspecified, scale primary to match secondary's scaling
        // ratio.
        if (maxPrimary == 0) {
            double ratio = (double) maxSecondary / (double) actualSecondary;
            return (int) (actualPrimary * ratio);
        }

        if (maxSecondary == 0) {
            return maxPrimary;
        }

        double ratio = (double) actualSecondary / (double) actualPrimary;
        int resized = maxPrimary;
        if (resized * ratio > maxSecondary) {
            resized = (int) (maxSecondary / ratio);
        }
        return resized;
    }

}