android基础学习之bitmap的常用用法

首先自己了解了一下屏幕分辨率的概念，手机的屏幕分辨率自己的理解大概就是像素值，如我们说的1080**720，而对应的手机的尺寸不同，所以其像素的密度也就不同，而图片都是由一个一个的像素点组成，就造成不同手机显示的图片有差异。

 

用到的屏幕分辨率  ldpi：320:240                          

                                       mdpi:480:320

                                       hdpi:800:480

                                       xhdpi:1280*720

                                      xxhdpi:1920*1080

通常ui切图都是按800*480来切图，如果有条件再切一套1280*720的图

 

dp和像素之间有对象的转换规则，这个规则由像素密度来确定

800*480大概都是4寸（斜对角线）左右的大小，如果是4寸对应的像素密度为233，谷歌文档会告诉我们不同的像素密度对应的dp与px的转换关系

 

所以dp也有一定得适配功能，但不能完全依仗。

而dimen也可以实现屏幕的适配功能，其文件内写下相应分辨率所对应的dp值，在建立不用的values-分辨率的名字的文件，这样再加载布局的时候就会到相应的分辨率文件中找到自己的dp值。

 

终极适配：有的手机比如魅族的，针对相应的手机再写一套布局，创建不同的layout-分辨率文件。

 

publicstaticDrawable scaleBitmap(Bitmap bitmapOrg, int setwh, int setht) {

 

      // / 加载需要操作的图片，这里是eoeAndroid的logo图片

      // Bitmap bitmapOrg =BitmapFactory.decodeResource(getResources(),

      // R.drawable.eoe_android);

 

      // 获取这个图片的宽和高

      int width =bitmapOrg.getWidth();

      int height =bitmapOrg.getHeight();

 

      // 定义预转换成的图片的宽度和高度

      int newWidth = setwh;

      int newHeight = setht;

 

      // 计算缩放率，新尺寸除原始尺寸

      float scaleWidth = ((float) newWidth) / width;

      float scaleHeight = ((float) newHeight) / height;

 

      // 创建操作图片用的matrix对象

      Matrixmatrix = newMatrix();

 

      // 缩放图片动作

      matrix.postScale(scaleWidth,scaleHeight);

 

      // 旋转图片动作

      // matrix.postRotate(45);

 

      // 创建新的图片

      BitmapresizedBitmap = Bitmap.createBitmap(bitmapOrg, 0, 0, width,

            height,matrix, true);

 

      // 将上面创建的Bitmap转换成Drawable对象，使得其可以使用在ImageView, ImageButton中

      BitmapDrawablebmd = newBitmapDrawable(resizedBitmap);

 

      return bmd;

   }

 

 

/********************* Drawable转Bitmap ************************/

   publicstatic BitmapdrawabletoBitmap(Drawable drawable) {

      int width =drawable.getIntrinsicWidth();

      int height =drawable.getIntrinsicWidth();

 

      Bitmapbitmap = Bitmap.createBitmap(width, height, drawable

            .getOpacity()!= PixelFormat.OPAQUE? Bitmap.Config.ARGB_8888

            :Bitmap.Config.RGB_565);

      Canvascanvas = newCanvas(bitmap);

      drawable.setBounds(0,0, width, height);

 

      drawable.draw(canvas);

 

      return bitmap;

   }

 

 

//简单的下载网络图片

publicstaticBitmap getNetBitmap(String strUrl, Context context) {

      // LogUtil.e(TAG, "getBitmap from net");

      Bitmapbitmap = null;

      NetWorkUtil.getNetWorkInfoType(context);

      if (!NetWorkUtil.NO_NETWORK) {// 有网络

         try {

            URLurl = newURL(strUrl);

            HttpURLConnectioncon = (HttpURLConnection) url

                   .openConnection();

            con.setDoInput(true);

            con.connect();

            InputStreamin = con.getInputStream();

            bitmap= BitmapFactory.decodeStream(in);

            // FileOutputStream out = newFileOutputStream(file.getPath());

            // bitmap.compress(Bitmap.CompressFormat.PNG,100, out);

            // out.flush();

            // out.close();

            in.close();

         }catch(MalformedURLException e) {

            // bitmap=null;

            e.printStackTrace();

         }catch(IOException e) {

            // bitmap=null;

            e.printStackTrace();

         }finally{

 

         }

      }

      return bitmap;

   }

 

//将图片切成圆形

   publicstatic BitmaptoRoundBitmap(Bitmap bitmap) {

      int width =bitmap.getWidth();

      int height =bitmap.getHeight();

      float roundPx;

      float left, top, right,bottom, dst_left, dst_top, dst_right, dst_bottom;

      if (width <= height) {

         roundPx= width / 2;

         top= 0;

         bottom= width;

         left= 0;

         right= width;

         height= width;

         dst_left= 0;

         dst_top= 0;

         dst_right= width;

         dst_bottom= width;

      }else{

         roundPx= height / 2;

         float clip = (width - height)/ 2;

         left= clip;

         right= width - clip;

         top= 0;

         bottom= height;

         width= height;

         dst_left= 0;

         dst_top= 0;

         dst_right= height;

         dst_bottom= height;

      }

 

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

      Canvascanvas = newCanvas(output);

 

      finalint color = 0xff424242;

      final Paint paint = new Paint();

      final Rect src = new Rect((int) left, (int) top, (int) right,

            (int) bottom);

      final Rect dst = new Rect((int) dst_left, (int) dst_top,

            (int) dst_right, (int) dst_bottom);

      final RectF rectF = new RectF(dst);

 

      paint.setAntiAlias(true);

 

      canvas.drawARGB(0,0, 0, 0);

      paint.setColor(color);

      canvas.drawRoundRect(rectF,roundPx, roundPx, paint);

 

      paint.setXfermode(newPorterDuffXfermode(Mode.SRC_IN));

      canvas.drawBitmap(bitmap,src, dst, paint);

      return output;

   }

 

//高斯模糊处理图片

* @param sentBitmap

    *           :要模糊的图片

    * @param radius

    *           :模糊度

    * @return

publicstaticBitmap createBlurBitmap(Bitmap sentBitmap, int radius) {

      Bitmapbitmap = sentBitmap.copy(sentBitmap.getConfig(), true);

      if (radius < 1) {

         return (null);

      }

      int w = bitmap.getWidth();

      int h = bitmap.getHeight();

      int[] pix = newint[w * h];

      bitmap.getPixels(pix,0, w, 0, 0, w, h);

      int wm = w - 1;

      int hm = h - 1;

      int wh = w * h;

      int div = radius + radius +1;

      int r[] = newint[wh];

      int g[] = newint[wh];

      int b[] = newint[wh];

      int rsum, gsum, bsum, x, y,i, p, yp, yi, yw;

      int vmin[] = newint[Math.max(w, h)];

      int divsum = (div + 1)>> 1;

      divsum*= divsum;

      int dv[] = newint[256 * divsum];

      for (i = 0; i < 256 *divsum; i++) {

         dv[i]= (i / divsum);

      }

      yw= yi = 0;

      int[][] stack = newint[div][3];

      int stackpointer;

      int stackstart;

      int[] sir;

      int rbs;

      int r1 = radius + 1;

      int routsum, goutsum,boutsum;

      int rinsum, ginsum, binsum;

      for (y = 0; y < h; y++){

         rinsum= ginsum = binsum = routsum = goutsum = boutsum = rsum = gsum = bsum = 0;

         for (i = -radius; i <=radius; i++) {

            p= pix[yi + Math.min(wm, Math.max(i, 0))];

            sir= stack[i + radius];

            sir[0]= (p & 0xff0000) >> 16;

            sir[1]= (p & 0x00ff00) >> 8;

            sir[2]= (p & 0x0000ff);

            rbs= r1 - Math.abs(i);

            rsum+= sir[0] * rbs;

            gsum+= sir[1] * rbs;

            bsum+= sir[2] * rbs;

            if (i > 0) {

                rinsum+= sir[0];

                ginsum+= sir[1];

                binsum+= sir[2];

            }else{

                routsum+= sir[0];

                goutsum+= sir[1];

                boutsum+= sir[2];

            }

         }

         stackpointer= radius;

         for (x = 0; x < w; x++){

            r[yi]= dv[rsum];

            g[yi]= dv[gsum];

            b[yi]= dv[bsum];

            rsum-= routsum;

            gsum-= goutsum;

            bsum-= boutsum;

            stackstart= stackpointer - radius + div;

            sir= stack[stackstart % div];

            routsum-= sir[0];

            goutsum-= sir[1];

            boutsum-= sir[2];

            if (y == 0) {

                vmin[x]= Math.min(x + radius + 1, wm);

            }

            p= pix[yw + vmin[x]];

            sir[0]= (p & 0xff0000) >> 16;

            sir[1]= (p & 0x00ff00) >> 8;

            sir[2]= (p & 0x0000ff);

            rinsum+= sir[0];

            ginsum+= sir[1];

            binsum+= sir[2];

            rsum+= rinsum;

            gsum+= ginsum;

            bsum+= binsum;

            stackpointer= (stackpointer + 1) % div;

            sir= stack[(stackpointer) % div];

            routsum+= sir[0];

            goutsum+= sir[1];

            boutsum+= sir[2];

            rinsum-= sir[0];

            ginsum-= sir[1];

            binsum-= sir[2];

            yi++;

         }

         yw+= w;

      }

      for (x = 0; x < w; x++){

         rinsum= ginsum = binsum = routsum = goutsum = boutsum = rsum = gsum = bsum = 0;

         yp= -radius * w;

         for (i = -radius; i <=radius; i++) {

            yi= Math.max(0, yp) + x;

            sir= stack[i + radius];

            sir[0]= r[yi];

            sir[1]= g[yi];

            sir[2]= b[yi];

            rbs= r1 - Math.abs(i);

            rsum+= r[yi] * rbs;

            gsum+= g[yi] * rbs;

            bsum+= b[yi] * rbs;

            if (i > 0) {

                rinsum+= sir[0];

                ginsum+= sir[1];

                binsum+= sir[2];

            }else{

                routsum+= sir[0];

                goutsum+= sir[1];

                boutsum+= sir[2];

            }

            if (i < hm) {

                yp+= w;

            }

         }

         yi= x;

         stackpointer= radius;

         for (y = 0; y < h; y++){

            pix[yi]= (0xff000000 & pix[yi]) | (dv[rsum] << 16)

                   |(dv[gsum] << 8) | dv[bsum];

            rsum-= routsum;

            gsum-= goutsum;

            bsum-= boutsum;

            stackstart= stackpointer - radius + div;

            sir= stack[stackstart % div];

            routsum-= sir[0];

            goutsum-= sir[1];

            boutsum-= sir[2];

            if (x == 0) {

                vmin[y]= Math.min(y + r1, hm) * w;

            }

            p= x + vmin[y];

            sir[0]= r[p];

            sir[1]= g[p];

            sir[2]= b[p];

            rinsum+= sir[0];

            ginsum+= sir[1];

            binsum+= sir[2];

            rsum+= rinsum;

            gsum+= ginsum;

            bsum+= binsum;

            stackpointer= (stackpointer + 1) % div;

            sir= stack[stackpointer];

            routsum+= sir[0];

            goutsum+= sir[1];

            boutsum+= sir[2];

            rinsum-= sir[0];

            ginsum-= sir[1];

            binsum-= sir[2];

            yi+= w;

         }

      }

      bitmap.setPixels(pix,0, w, 0, 0, w, h);

      return (bitmap);

   }