图片无限放大，不模糊，图片移动，仿微信图片放大 -

892848153

浏览: 960850 次

最近访客更多访客>>

andylao62

mdpsong

mft8899

xinxing185

博主相关

博客

微博

相册

留言

关于我

文章分类

社区版块

存档分类

图片无限放大，不模糊，图片移动，仿微信图片放大

原创作品，允许转载，转载时请务必以超链接形式标明文章原始出处、作者信息和本声明。否则将追究法律责任。http://7071976.blog.51cto.com/7061976/1208469

备注：本文关键内容是“OOM（Out Of Memory）异常"，跟 “移动时的截图起点规则”内容，其他部分没看也可以看的懂

写此程序背景

看到微信的图片浏览的强大功能，于是自己写了一个。原则上可以无限放大，但是放大部分像素必须有原图片的1个像素，最小也不能小于1*1像素。

思路：

功能解剖：

缩放：微信的缩放能缩放到用户满意的范围。（放大不会超过max倍，缩小不会超过min）

移动：当图片高与宽小于屏幕时，能移动图片到任意位置。当高或宽大于屏幕时，移动图片则会截取图片某一模块放大满屏显示。

最重要的一点就是图片放大时看不出来图片变模糊

解剖雏形：

假设用系统自带Matrix函数来控制放大缩小。

缩小: 可以缩小很小倍，当不易控制倍数(如1.25倍，但Matrix不会那么精确)

放大:但放大超出屏幕时，Bitmap.createBitmap会在内存中创建一个很大的图（或内存超出系统设定的值或宽高超出屏幕），导致显存或内存不足。

因为上条放大会出现问题所以本方案绝对不行。

解剖过度：

那么要有那么一种缩放方法满足下面条件

一、能几乎精确的缩小到某一个倍数

二、放大时内存不会溢出

基于缩放的截取方法想出以下移动方案

一、当放大时移动时计算某个参考点在图上移动的位置所占比列（x,y），高宽为屏幕高度/倍数

二、当缩小的图在屏幕范围之内，那么移动的效果通过移动ImageView的位置实现

方案：因为缩放的关键是放大，所以可以考虑放大时用截取一段图*n倍不会溢出的图

截图方案: 一、看到截取就想到用画布canvas解决（于是创建了一个MyBitMap类）能截永远不会内存溢出的放大图。并且图像不会模糊（canvas优秀之处）。

补充：OOM（Out Of Memory）异常

1.放大时不模糊的实现：利用canvas获取放大后的图，就能解决安常规放大后模糊的现状。

2.图片不溢出的实现：在canvas放大时限制图片的大小不超出屏幕就行。

溢出的情况

一、图片的高或宽超出了屏幕。所以在canvas放大时限制图片的大小不超出屏幕就行。

二、某一个bitmap超出了系统对单张图片的限制大小5MB（5MB根据系统不同会有差别）。利用canve截图到的图才几十kb。如果利用常规的Matrix在原来的图基础上来放大(放大后的图片大小为原图大小*当前倍数的平方)，就会有超限（5MB）溢出。

import android.graphics.Bitmap;

import android.graphics.Bitmap.Config;

import android.graphics.Canvas;

import android.graphics.Paint;

import android.graphics.Rect;

import android.widget.ImageView.ScaleType;
/**

 *此处函数是得到剪切的图片

 * @author ZhangJianLin

 *

 */

public class MyBitMap {

    public MyBitMap() {

    // TODO Auto-generated constructor stub
}

    /**

     *

     * @param unscaledBitmap the bitmap of source

     * @param dstWidth what width you want to set

     * @param dstHeight What width you want to set

     * @param scalingLogic it is ScaleType

     * @return the scaled bitmap

     */

    public static Bitmap createScaledBitmap(Bitmap unscaledBitmap, int dstWidth, int dstHeight, ScaleType scalingLogic) {

          Rect srcRect = calculateSrcRect(unscaledBitmap.getWidth(), unscaledBitmap.getHeight(), dstWidth, dstHeight, scalingLogic);

          Rect dstRect = calculateDstRect(unscaledBitmap.getWidth(), unscaledBitmap.getHeight(), dstWidth, dstHeight, scalingLogic);

          Bitmap scaledBitmap = Bitmap.createBitmap(dstRect.width(), dstRect.height(), Config.ARGB_8888);

          Canvas canvas = new Canvas(scaledBitmap);

          canvas.drawBitmap(unscaledBitmap, srcRect, dstRect, new Paint(Paint.FILTER_BITMAP_FLAG));

          return scaledBitmap;

          }

    //根据dstWOrH计算原图应该截取的截图合适的高宽比例图

    public static Rect calculateSrcRect(int srcWidth, int srcHeight, int dstWidth, int dstHeight, ScaleType scalingLogic) {

          if (scalingLogic == ScaleType.CENTER_CROP) {

            final float srcAspect = (float)srcWidth / (float)srcHeight;

            final float dstAspect = (float)dstWidth / (float)dstHeight;

            if (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 = (int)(srcHeight - srcRectHeight) / 2;

              return new Rect(0, scrRectTop, srcWidth, scrRectTop + srcRectHeight);

            }

          } else {

            return new Rect(0, 0, srcWidth, srcHeight);

          }

        }

    //根据dstWOrH计算原图应该截取的期望图合适的高宽比例图

        public static Rect calculateDstRect(int srcWidth, int srcHeight, int dstWidth, int dstHeight, ScaleType scalingLogic) {

          if (scalingLogic == ScaleType.FIT_XY) {

            final float srcAspect = (float)srcWidth / (float)srcHeight;

            final float dstAspect = (float)dstWidth / (float)dstHeight;

            if (srcAspect > dstAspect) {

              return new Rect(0, 0, dstWidth, (int)(dstWidth / srcAspect));

            } else {

              return new Rect(0, 0, (int)(dstHeight * srcAspect), dstHeight);

            }

          } else {

            return new Rect(0, 0, dstWidth, dstHeight);

          }

        }

        /**

         *

         * @param unscaledBitmap the bitmap of source

         * @param scale the scale you want

         * @param scalingLogic it is ScaleType

         * @return the scaled bitmap

         */

        //根据放大倍数获得截取图安scale放大的图

        public static Bitmap createBMScaleBitmap(Bitmap unscaledBitmap, Double scale, ScaleType scalingLogic){

        int dstWidth = (int)(unscaledBitmap.getWidth()* scale);

        int dstHeight = (int)(unscaledBitmap.getHeight()*scale);

        return createScaledBitmap(unscaledBitmap, dstWidth, dstHeight, scalingLogic);

    }

}

移动时的截图起点规则

每缩放一次，就以图的中心为截获图的中心（Ox，Oy），起点为（Ox-needwidth/2,Oy - needhight/2)。

在缩放时，把放大后的图在逻辑上的坐标划分为m份，（1单位为屏幕的宽或高），同时每移动一次，就移动1/4份（即每次移动1/4屏幕）。 (单次移动的宽或高像素为 (bitmapWidth/m*n或bitmapHight/m*n，其中n是缩放的倍数，m为计算缩放后的图片高宽跟屏幕对应的宽高的比例，以此得到的值作为x或y的坐标最大值，坐标单位为一个屏幕，每滑次移动半个屏幕或1/3屏幕

结合安卓的滑动或移动的灵敏度，能完美的模拟出效果图。（亲测，如果移动规则用跟踪手的移动位移来移动图片是行不通的，不知道市面上能作出这样的效果是什么样的一个算法，还有待探究）
核心实现代码及注释如下

package com.imageopen;

import android.app.Activity;

import android.graphics.Bitmap;

import android.os.Bundle;

import android.util.DisplayMetrics;

import android.util.Log;

import android.view.Menu;

import android.view.MotionEvent;

import android.view.View;

import android.view.View.OnClickListener;

import android.view.View.OnTouchListener;

import android.view.Window;

import android.widget.Button;

import android.widget.ImageView;

import android.widget.ImageView.ScaleType;

public class BigzoonImage extends Activity {

    ImageView myImageView;

    Button bigButton;//放大按钮

    Button smallButton;//缩小按钮

    View myButtons;

    private Bitmap myBitmap;

    private double bigSize = 1.25;//每次放大的比列

    private double smallSize = 0.8;//每次缩小的比例

    double size = 1;//当前放大的倍数

    double pixel = 30.00;//限制图片缩小时的最小像素

    int bmpWidth;//图片宽度

    int bmpHight;//图片高度

    int bmpSizeWidth;//放大后的图片宽度bmpwidth*size

    int bmpSizeHight;

    int x ;//

    int y ;//

    int screenWidth;      // 屏幕宽（像素，如：480px）

    int screenHeight;     // 屏幕高（像素，如：800px）

    int dstHeight;

    int dstWidth;

    @Override

    protected void onCreate(Bundle savedInstanceState) {

        requestWindowFeature(Window.FEATURE_NO_TITLE);

        super.onCreate(savedInstanceState);

        setContentView(R.layout.bigzoonimage_main);

        init();

    }

    private void init(){//初始化各参数的值

        myImageView = (ImageView)findViewById(R.id.bitmap_image);

        bigButton = (Button)findViewById(R.id.button_big);

        smallButton = (Button)findViewById(R.id.button_small);

        myButtons = (View)findViewById(R.id.bitmap_button);

        MyBitmapFactory myBitmapFactory = new MyBitmapFactory(this);

        myBitmap = myBitmapFactory.getDrawBmp(R.drawable.bitmap_test);//事先加载一张图片

        myImageView.setImageBitmap(myBitmap);

        myImageView.setOnTouchListener(ImageOpenListener);

        bigButton.setOnClickListener(sizeButton);//添加按钮触发事件

        smallButton.setOnClickListener(sizeButton);//同上

        DisplayMetrics dm = new DisplayMetrics();  //声明一个屏幕像素的类屏幕像素

        dm = getResources().getDisplayMetrics();  //得到屏幕像素

        screenWidth  = dm.widthPixels;      // 屏幕宽（像素，如：480px）

        screenHeight = dm.heightPixels;     // 屏幕高（像素，如：800px）

    }

    private void big(){//放大时图片的变化

        size = bigSize * size;

        Bitmap newBitmap = myBitmap;

        newBitmap = bigCal(myBitmap);

        newBitmap = MyBitMap.createScaledBitmap(newBitmap, dstWidth, dstHeight, ScaleType.FIT_XY);

        myImageView.setImageBitmap(newBitmap);

    }

    private void small(){//缩小时图片的变化

        size = smallSize * size;

        Bitmap newBitmap = myBitmap;//得到原图的截取图

        newBitmap = bigCal(newBitmap);

        newBitmap = MyBitMap.createScaledBitmap(newBitmap, dstWidth, dstHeight, ScaleType.FIT_XY);

        myImageView.setImageBitmap(newBitmap);

    }

    private OnClickListener sizeButton = new OnClickListener() {//放大缩小的事件

        @Override

        public void onClick(View v) {

            // TODO Auto-generated method stub

            if(v == bigButton){

                big();

                }

            else small();

        }

    };

    //每缩放一次，就以图的中心为截获图的中心（Ox，Oy），起点为（Ox-needwidth/2,Oy - needhight/2)，宽高为屏幕宽高的图。

    public Bitmap bigCal(Bitmap bitmap){//缩放得到原图的截取图

        bmpWidth = bitmap.getWidth();

        bmpHight = bitmap.getHeight();

        //放大的size最小值，16是指限制的截取的图片最小像素，要是缩小的很小，那么一丁点没有意义，这里的16看个人意思

        int sizeMax = Math.min(myBitmap.getWidth()/16, myBitmap.getHeight()/16);//限定放大的最大倍数

        double sizeMin = Math.max(pixel/myBitmap.getWidth(), pixel/myBitmap.getHeight());//限制缩小的size最小倍数

        if(size > sizeMax){

            size = sizeMax;

        }

        if(size < sizeMin){

            size = sizeMin;

        }

        bmpSizeWidth = (int)(bmpWidth*size);

        bmpSizeHight = (int)(bmpHight*size);

        if(screenWidth > bmpSizeWidth){

            x = 0;

            dstWidth = bmpSizeWidth;

        }else{

            x = (int)((bmpSizeWidth - screenWidth)/(2*size));

            bmpWidth = (int)(screenWidth / size);

            dstWidth = screenWidth;

        }

        if(screenHeight > bmpSizeHight){

            y = 0;

            dstHeight = bmpSizeHight;

        }else{

            y = (int)((bmpSizeHight - screenHeight)/(2*size));//放大时计算以中心的为截取中心的所要截图的左上点坐标(x,y)

            bmpHight = (int)(screenHeight / size);

            dstHeight = screenHeight;

        }

        bitmap = Bitmap.createBitmap(bitmap, x, y, bmpWidth, bmpHight);

        return bitmap;

        }

    //计算缩放的倍数跟屏幕的比例，以得到的值作为x或y的坐标最大值，坐标单位为一个屏幕，每滑动次移动半个屏幕或1/3屏幕

    public double rowOrCowNum(int sizeBitmapWH, int screenWH){

        double num = (sizeBitmapWH * size)/screenWH;

        return num;

    }

    public Bitmap movCal(Bitmap bitmap, int dx, int dy){//计算移动后的要截取的图

        double coordinateX = rowOrCowNum(myBitmap.getWidth() , screenWidth);//缩放后x坐标，

        double coordinateY = rowOrCowNum(myBitmap.getHeight(), screenHeight);//缩放后y的坐标

        if(coordinateX > 1){

            if(dx > 0){

            x -= (myBitmap.getWidth()/(coordinateX * 4));

            if(x < 0){

                x = 0;

            }

            }

            if(dx < 0){

                x += (myBitmap.getWidth()/(coordinateX *4));

                if(x > (myBitmap.getWidth() - bmpWidth)){

                    x = myBitmap.getWidth() - bmpWidth;

                }

            }

        }

            if(coordinateY > 1){

                if(dy > 0){

                y -= (myBitmap.getHeight()/(coordinateY * 4));

                if(y < 0){

                    y = 0;

                }

                }

                if(dy < 0){

                    y += (myBitmap.getHeight()/(coordinateY *4));

                    if(y > (myBitmap.getHeight() - bmpHight)){

                        y = myBitmap.getHeight() - bmpHight;

                    }

                }

        }

        bitmap = Bitmap.createBitmap(bitmap, x, y, bmpWidth, bmpHight);

        bitmap = MyBitMap.createScaledBitmap(bitmap, dstWidth, dstHeight, ScaleType.FIT_XY);

        return bitmap;

    }

    private OnTouchListener ImageOpenListener = new OnTouchListener() {//移动监听

        int lastX;

        int lastY;

        int left;//图片的左边界的坐标

        int right;//图片右边界坐标

        int top;//图片上边界的坐标

        int bottom;//图片下边界的坐标

        @Override

        public boolean onTouch(View v, MotionEvent event) {

            // TODO Auto-generated method stub

            switch(event.getAction()){

            case MotionEvent.ACTION_DOWN:

                lastX = (int)event.getRawX();

                lastY = (int)event.getRawY();

                break;

            case MotionEvent.ACTION_MOVE:

                int dx = (int)event.getRawX() - lastX;//dx为在屏幕的x轴上移动的距离

                int dy = (int)event.getRawY() - lastY;//dy为在屏幕的y轴上移动的距离

                Bitmap newBitmap;

                //计算缩放的图片是否找出屏幕范围，如果是

                if(bmpSizeWidth > screenWidth||bmpSizeHight > screenHeight){

                    if(bmpSizeWidth > screenWidth){

                        left = 0;

                        right = screenWidth;

                    }else{

                        left = v.getLeft() + dx;

                        right = v.getRight() + dx;

                    }

                    if(bmpSizeHight > screenHeight){

                        top = 0;

                        bottom = screenHeight;

                    }else {

                        top = v.getTop() + dy;

                        bottom = v.getBottom() + dy;

                    }

                    if((dx > 3 || dx < -3) && (dy > 3 ||dy  < -3)){//设置灵敏度，一定要设置

                    newBitmap = movCal(myBitmap, dx, dy);

                    myImageView.setImageBitmap(newBitmap);

                    }

                }

                else{//如果没有超出则移动ImageView

                    left = v.getLeft() + dx;

                    top = v.getTop() + dy;

                    bottom = v.getBottom() + dy;

                    right = v.getRight() + dx;

                }

                v.layout(left, top, right, bottom);

                lastX = (int)event.getRawX();

                lastY = (int)event.getRawY();

                break;

            }

            return true;

        }

    };

    @Override

    protected void onPause() {

        // TODO Auto-generated method stub

        System.exit(0);

        super.onPause();

    }

    @Override

    protected void onStop() {

        // TODO Auto-generated method stub

        System.exit(0);

        super.onStop();

    }

    @Override

    public boolean onCreateOptionsMenu(Menu menu) {

        // Inflate the menu; this adds items to the action bar if it is present.

        getMenuInflater().inflate(R.menu.activity_main, menu);

        return true;

    }
}

另外有一个辅助类，就是获取各类渠道图片的封装类

import java.io.ByteArrayOutputStream;

import java.io.IOException;

import java.io.InputStream;

import java.net.HttpURLConnection;

import java.net.MalformedURLException;

import java.net.URL;

import android.content.Context;

import android.graphics.Bitmap;

import android.graphics.Bitmap.CompressFormat;

import android.graphics.Bitmap.Config;

import android.graphics.BitmapFactory;

import android.graphics.Canvas;

import android.graphics.LinearGradient;

import android.graphics.Matrix;

import android.graphics.Paint;

import android.graphics.PorterDuff.Mode;

import android.graphics.PorterDuffXfermode;

import android.graphics.Shader.TileMode;

import android.util.Base64;
/**

 * 功能：得到原始的bitmap,就是unscaledbitmap;将得到bitmap字节流

 * @author ZhangJianLin

 *

 */

public class MyBitmapFactory {

    Context context;

    public MyBitmapFactory(Context context) {

    // TODO Auto-generated constructor stub

        this.context = context;
}

    public Bitmap getFileBmp(String path){//通过路径获得图片

        Bitmap bm = BitmapFactory.decodeFile(path);

        return bm;

    }

    public Bitmap getDrawBmp(int id){//通过本项目id获得图片

        Bitmap bm = BitmapFactory.decodeResource(context.getResources(), id);

        return bm;

    }

    public Bitmap getStringBmp(InputStream inputstring){//从流中获取图片

        Bitmap bm = BitmapFactory.decodeStream(inputstring);

        return bm;

    }

    public Bitmap getArrayBmp(byte[] data, int offset, int length){//从字节转化成图片

        Bitmap bm = BitmapFactory.decodeByteArray(data, offset, length);

        return bm;

    }

    //获得带倒影的图片方法

    public static Bitmap createReflectionImageWithOrigin(Bitmap bitmap){

    final int reflectionGap = 4;

    int width = bitmap.getWidth();

    int height = bitmap.getHeight();

    Matrix matrix = new Matrix();

    matrix.preScale(1, -1);

    Bitmap reflectionImage = Bitmap.createBitmap(bitmap,

    0, height/2, width, height/2, matrix, false);

    Bitmap bitmapWithReflection = Bitmap.createBitmap(width, (height + height/2),

    Config.ARGB_8888);

    Canvas canvas = new Canvas(bitmapWithReflection);

    canvas.drawBitmap(bitmap, 0, 0, null);

    Paint deafalutPaint = new Paint();

    canvas.drawRect(0, height,width,height + reflectionGap,

    deafalutPaint);

    canvas.drawBitmap(reflectionImage, 0, height + reflectionGap, null);

    Paint paint = new Paint();

    LinearGradient shader = new LinearGradient(0,

    bitmap.getHeight(), 0, bitmapWithReflection.getHeight()

    + reflectionGap, 0x70ffffff, 0x00ffffff, TileMode.CLAMP);

    paint.setShader(shader);

    // Set the Transfer mode to be porter duff and destination in

    paint.setXfermode(new PorterDuffXfermode(Mode.DST_IN));

    // Draw a rectangle using the paint with our linear gradient

    canvas.drawRect(0, height, width, bitmapWithReflection.getHeight()

    + reflectionGap, paint);

    return bitmapWithReflection;

    }

    public Bitmap stringtoBitmap(String string){//从string到bitmap

        //将字符串转换成Bitmap类型

        Bitmap bitmap=null;

        try {

        byte[]bitmapArray;

        bitmapArray=Base64.decode(string, Base64.DEFAULT);

    bitmap=BitmapFactory.decodeByteArray(bitmapArray, 0, bitmapArray.length);

    } catch (Exception e) {

    e.printStackTrace();

    }

        return bitmap;

        }

        public String bitmaptoString(Bitmap bitmap){

    //将Bitmap转换成字符串

        String string=null;

        ByteArrayOutputStream bStream=new ByteArrayOutputStream();

        bitmap.compress(CompressFormat.PNG,100,bStream);

        byte[]bytes=bStream.toByteArray();

        string=Base64.encodeToString(bytes,Base64.DEFAULT);

        return string;

        }

        public Bitmap returnBitMap(String url) {//从网络中获得图片

            URL myFileUrl = null;

            Bitmap bitmap = null;

            try {

                    myFileUrl = new URL(url);

            } catch (MalformedURLException e) {

                    e.printStackTrace();

            }

            try {

                    HttpURLConnection conn = (HttpURLConnection) myFileUrl

                                    .openConnection();

                    conn.setDoInput(true);

                    conn.connect();

                    InputStream is = conn.getInputStream();

                    bitmap = BitmapFactory.decodeStream(is);

                    is.close();

            } catch (IOException e) {

                    e.printStackTrace();

            }

            return bitmap;

    }

}

本实验中所用到的布局如下

<RelativeLayout 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"

    tools:context=".MainActivity" >

    <ImageView

        android:id="@+id/bitmap_image"

        android:layout_width="wrap_content"

        android:layout_height="wrap_content"

        android:layout_centerHorizontal="true"

        android:layout_centerVertical="true"

        android:src="@drawable/ic_launcher" />

    <LinearLayout

        android:id="@+id/bitmap_button"

        android:layout_width="80dp"

        android:layout_height="40dp"

        android:layout_alignParentBottom="true"

        android:layout_alignParentLeft="true"

        android:layout_marginBottom="16dp"

        android:layout_marginLeft="14dp"

        android:orientation="horizontal" >

        <Button

            android:id="@+id/button_small"

            android:layout_width="40dp"

            android:layout_height="40dp"

            android:background="@drawable/bitmap_small" />

        <Button

            android:id="@+id/button_big"

            android:layout_width="40dp"

            android:layout_height="40dp"

            android:background="@drawable/bitmap_big" />

    </LinearLayout>

</RelativeLayout>