图片处理工具类

import android.content.Context;
import android.content.Intent;
import android.content.res.Resources;
import android.database.Cursor;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.graphics.Canvas;
import android.graphics.Color;
import android.graphics.ImageFormat;
import android.graphics.Matrix;
import android.graphics.Paint;
import android.graphics.PorterDuff;
import android.graphics.PorterDuffXfermode;
import android.graphics.Rect;
import android.graphics.RectF;
import android.graphics.YuvImage;
import android.hardware.Camera;
import android.media.ExifInterface;
import android.net.Uri;
import android.os.Environment;
import android.provider.MediaStore;
import android.text.Layout;
import android.text.StaticLayout;
import android.text.TextPaint;
import android.util.Base64;
import android.util.Log;


import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.UnsupportedEncodingException;
import java.lang.ref.SoftReference;
import java.net.HttpURLConnection;
import java.net.URL;
import java.text.SimpleDateFormat;
import java.util.Date;


public class PictureUtil {
    private static final String TAG = "PictureUtil";
    private static final String fileDirectory = Environment.getExternalStorageDirectory() + File.separator + "photo";

    public static String getMyFileDir() {
        return fileDirectory;
    }


    private static String getImagePath(Context context, Uri uri, String selection) {
        String path = null;
        Cursor cursor = context.getContentResolver().query(uri, null, selection, null, null);
        if (cursor != null) {
            if (cursor.moveToFirst()) {
                path = cursor.getString(cursor.getColumnIndex(MediaStore.Images.Media.DATA));
            }
            cursor.close();
        }
        return path;
    }

    public static void mkdirMyPetRootDirectory() {
        boolean isSdCardExist = Environment.getExternalStorageState().equals(Environment.MEDIA_MOUNTED);// 判断sdcard是否存在
        if (isSdCardExist) {
            File MyPetRoot = new File(getMyFileDir());
            if (!MyPetRoot.exists()) {
                try {
                    MyPetRoot.mkdir();
                    Log.d(TAG, "mkdir success");
                } catch (Exception e) {
                    Log.e(TAG, "exception->" + e.toString());
                }
            }
        }
    }

    /**
     * 将bitmap转为Base64字符串
     *
     * @param bitmap
     * @return
     */
    public static String bitmapToString(Bitmap bitmap) {
        ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
        bitmap.compress(Bitmap.CompressFormat.JPEG, 50, outputStream);
        byte[] bytes = outputStream.toByteArray();
        //Base64算法加密，当字符串过长（一般超过76）时会自动在中间加一个换行符，字符串最后也会加一个换行符。
        // 导致和其他模块对接时结果不一致。所以不能用默认Base64.DEFAULT，而是Base64.NO_WRAP不换行
        return Base64.encodeToString(bytes, Base64.NO_WRAP);
    }

    /**
     * 将base64字符串转为bitmap
     *
     * @param base64String
     * @return
     */
    public static Bitmap base64ToBitmap(String base64String) {
        byte[] bytes = Base64.decode(base64String, Base64.NO_WRAP);
        Bitmap bitmap = BitmapFactory.decodeByteArray(bytes, 0, bytes.length);
        return bitmap;
    }

    public static File compress(String path) {

        File outputFile = new File(path);
        long fileSize = outputFile.length();
        final long fileMaxSize = 200 * 1024;
        if (fileSize >= fileMaxSize) {
            BitmapFactory.Options options = new BitmapFactory.Options();
            options.inJustDecodeBounds = true;
            BitmapFactory.decodeFile(path, options);
            int height = options.outHeight;
            int width = options.outWidth;

            double scale = Math.sqrt((float) fileSize / fileMaxSize);
            options.outHeight = (int) (height / scale);
            options.outWidth = (int) (width / scale);
            options.inSampleSize = (int) (scale + 0.5);
            options.inJustDecodeBounds = false;

            Bitmap bitmap = BitmapFactory.decodeFile(path, options);
            outputFile = new File(saveMyBitmap(outputFile.getName()));
            FileOutputStream fos = null;
            try {
                fos = new FileOutputStream(outputFile);
                bitmap.compress(Bitmap.CompressFormat.JPEG, 50, fos);
                fos.close();
            } catch (Exception e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            /*if (!bitmap.isRecycled()) {
                bitmap.recycle();
            }else{
                File tempFile = outputFile;
                outputFile = new File(outputFile.getPath());
                copyFileUsingFileChannels(tempFile, outputFile);
            }*/

        }
        return outputFile;

    }


    private static String saveMyBitmap(String filename) {
        String baseDir = Environment.getExternalStorageDirectory().getAbsolutePath() + "/zhwj/";
        String filePath = baseDir + filename;
        File dir = new File(baseDir);
        if (!dir.exists()) {
            dir.mkdir();
        }

        File f = new File(filePath);
        try {
            f.createNewFile();
        } catch (IOException e) {
            e.printStackTrace();
        }


        return filePath;
    }

    /**
     * 保存图片到本地
     *
     * @param
     * @return
     */
    public static String saveBitmap(Bitmap bitmap, String name) {
        String savePath = Environment.getExternalStorageDirectory().getAbsolutePath() + "/kqxt/banner/";
        File filePic;
        try {
            filePic = new File(savePath + name + ".jpg");
            if (!filePic.exists()) {
                filePic.getParentFile().mkdirs();
                filePic.createNewFile();
            }

            FileOutputStream fos = new FileOutputStream(filePic);
            bitmap.compress(Bitmap.CompressFormat.JPEG, 100, fos);
            fos.flush();
            fos.close();
        } catch (IOException e) {
            e.printStackTrace();
            Log.d("xxx", "saveBitmap: 2return");
            return null;
        }
        return filePic.getAbsolutePath();
    }

    /**
     * 保存图片到本地
     *
     * @param bitmap 图片
     * @param name   图片名字
     * @return 返回图片在本地地址
     */
    public static String saveBitmapPng(Bitmap bitmap, String name) {
//        String savePath;
        String savePath = Environment.getExternalStorageDirectory().getAbsolutePath() + "/zfzd/";
        File filePic;
        try {
            filePic = new File(savePath + name + ".jpg");
            if (!filePic.exists()) {
                filePic.getParentFile().mkdirs();
                filePic.createNewFile();
            }
            FileOutputStream fos = new FileOutputStream(filePic);
            bitmap.compress(Bitmap.CompressFormat.JPEG, 100, fos);
            fos.flush();
            fos.close();
        } catch (IOException e) {
            e.printStackTrace();
            Log.d("xxx", "saveBitmap: 2return");
            return null;
        }
        return filePic.getAbsolutePath();
    }

    /**
     * 根据本地地址得到bitmap图片
     *
     * @param filePath 图片的本地路径
     * @return 返回显示的bitmap
     */
    public static Bitmap getBitmap(String filePath) {
        Bitmap cardBitmap = null;
        FileInputStream fis = null;
        try {
            fis = new FileInputStream(filePath);
            cardBitmap = BitmapFactory.decodeStream(fis);
            return cardBitmap;
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }
        return cardBitmap;
    }

    //图片添加水印
    public static Bitmap AddTimeWatermark(Bitmap mBitmap, String str) {
        //获取原始图片与水印图片的宽与高
        int mBitmapWidth = mBitmap.getWidth();
        int mBitmapHeight = mBitmap.getHeight();
        Bitmap mNewBitmap = Bitmap.createBitmap(mBitmapWidth, mBitmapHeight, Bitmap.Config.ARGB_8888);
        Canvas mCanvas = new Canvas(mNewBitmap);
        //向位图中开始画入MBitmap原始图片
        mCanvas.drawBitmap(mBitmap, 0, 0, null);
        //添加文字
        TextPaint mPaint = new TextPaint();
        String mFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date());
        //String mFormat = TingUtils.getTime()+"\n"+" 纬度:"+GpsService.latitude+"  经度:"+GpsService.longitude;
        mPaint.setColor(Color.WHITE);
        mPaint.setTextSize(30);
        //水印的位置坐标
//        String userName = SharedPreferenceUtil.getString(Constants.USERNAME, "");
//        String project_name = SharedPreferenceUtil.getString(Constants.PROJECT_NAME, "");
//        String org_name = SharedPreferenceUtil.getString(Constants.ORG_NAME, "");
//        String waterStr =
//                "所在项目：" + project_name + "\n" +
//                        "所在组织：" + org_name + "\n" +
//                        "打卡时间：" + str + "\n"
//                        + "考勤机编号：" + userName;
//        mCanvas.drawText(waterStr, (mBitmapWidth * 1) / 10, (mBitmapHeight * 14) / 15, mPaint);
        StaticLayout layoutopen = new StaticLayout(mFormat, mPaint, (int) 800, Layout.Alignment.ALIGN_NORMAL, 1.0F, 0.0F, true);
        mCanvas.save();
        mCanvas.translate((mBitmapWidth * 1) / 10, (mBitmapHeight * 13) / 15);
        layoutopen.draw(mCanvas);

        mCanvas.restore();

        return mNewBitmap;
    }

    //去掉身份证空格
    public static String getLocalCard(String card) {
        byte bysIdCode[] = new byte[36];
        bysIdCode = card.getBytes();
        String cardStr = null;
        try {
            cardStr = new String(bysIdCode, "UTF-16LE");
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        }
        return cardStr;
    }

    //判定文件是否存在
    public static boolean fileIsExists(String strFile) {
        try {
            File f = new File(strFile);
            if (!f.exists()) {
                return false;
            }

        } catch (Exception e) {
            return false;
        }

        return true;
    }

    //url转bitmap
    public static Bitmap getUrlBitmap(String imgUrl) {
        InputStream inputStream = null;
        ByteArrayOutputStream outputStream = null;
        URL url = null;
        try {
            url = new URL(imgUrl);
            HttpURLConnection httpURLConnection = (HttpURLConnection) url.openConnection();
            httpURLConnection.setRequestMethod("GET");
            httpURLConnection.setReadTimeout(2000);
            httpURLConnection.connect();
            if (httpURLConnection.getResponseCode() == 200) {
                //网络连接成功
                inputStream = httpURLConnection.getInputStream();
                outputStream = new ByteArrayOutputStream();
                byte buffer[] = new byte[1024 * 8];
                int len = -1;
                while ((len = inputStream.read(buffer)) != -1) {
                    outputStream.write(buffer, 0, len);
                }
//                inputStream.close();


                byte[] bu = outputStream.toByteArray();
                BitmapFactory.Options option = new BitmapFactory.Options();
                option.inSampleSize = 2;
                InputStream input = null;
                input = new ByteArrayInputStream(bu);
                SoftReference softRef = new SoftReference(BitmapFactory.decodeStream(
                        input, null, option));
                Bitmap bitmap = (Bitmap) softRef.get();
                if (bu != null) {
                    bu = null;
                }
                if (input != null) {
                    input.close();
                }

//                Bitmap bitmap = BitmapFactory.decodeByteArray(bu, 0, bu.length);
//                ByteArrayOutputStream baos = new ByteArrayOutputStream();
//                int options = 70;
//                //压缩图片到100kb
//                while (baos.toByteArray().length / 1024 > 100) {
//                    baos.reset();
//                    options -= 10;
//                    bitmap.compress(Bitmap.CompressFormat.JPEG, options, baos);
//                }
//                bitmap.compress(Bitmap.CompressFormat.JPEG, options, baos);
//                byte[] bytes = baos.toByteArray();
//
//                bitmap = BitmapFactory.decodeByteArray(bytes, 0, bytes.length);
//                Log.d(TAG, "getUrlBitmap: size "+bytes.length);
                return bitmap;
            } else {
                Log.d(TAG, "网络连接失败----" + httpURLConnection.getResponseCode());
            }
        } catch (Exception e) {
            // TODO: handle exception
        } finally {
            if (inputStream != null) {
                try {
                    inputStream.close();
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
            if (outputStream != null) {
                try {
                    outputStream.close();
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
        }
        return null;
    }

    /**
     * 根据图片要显示的宽和高，对图片进行压缩，避免OOM
     *
     * @param path
     * @param width  要显示的imageview的宽度
     * @param height 要显示的imageview的高度
     * @return
     */
    public static Bitmap decodeSampledBitmapFromPath(String path, int width, int height) {

//      获取图片的宽和高，并不把他加载到内存当中
        BitmapFactory.Options options = new BitmapFactory.Options();
        options.inJustDecodeBounds = true;
        BitmapFactory.decodeFile(path, options);

        options.inSampleSize = caculateInSampleSize(options, width, height);
//      使用获取到的inSampleSize再次解析图片(此时options里已经含有压缩比 options.inSampleSize，再次解析会得到压缩后的图片，不会oom了 )
        options.inJustDecodeBounds = false;
        Bitmap bitmap = BitmapFactory.decodeFile(path, options);
        return bitmap;

    }

    /**
     * 根据需求的宽和高以及图片实际的宽和高计算SampleSize
     *
     * @param options
     * @param reqWidth  要显示的imageview的宽度
     * @param reqHeight 要显示的imageview的高度
     * @return
     * @compressExpand 这个值是为了像预览图片这样的需求，他要比所要显示的imageview高宽要大一点，放大才能清晰
     */
    private static int caculateInSampleSize(BitmapFactory.Options options, int reqWidth, int reqHeight) {
        int width = options.outWidth;
        int height = options.outHeight;

        int inSampleSize = 1;

        if (width >= reqWidth || height >= reqHeight) {

            int widthRadio = Math.round(width * 1.0f / reqWidth);
            int heightRadio = Math.round(width * 1.0f / reqHeight);

            inSampleSize = Math.max(widthRadio, heightRadio);

        }

        return inSampleSize;
    }

    /**
     * 将图片转换成十六进制字符串
     *
     * @param
     * @return
     */
    public static String bitmapTo16(String path) {
        Bitmap bitmap = BitmapFactory.decodeFile(path);
        ByteArrayOutputStream stream = new ByteArrayOutputStream();
        bitmap.compress(Bitmap.CompressFormat.JPEG, 100, stream);// (0 - 100)压缩文件
        byte[] bt = stream.toByteArray();
        String photoStr = byte2hex(bt);
        Log.d("lll", "bitmapTo16: " + photoStr);
        return photoStr;
    }

    /**
     * 二进制转字符串
     *
     * @param b
     * @return
     */
    public static String byte2hex(byte[] b) {
        StringBuilder sb = new StringBuilder();
        String stmp = "";
        for (int n = 0; n < b.length; n++) {
            stmp = Integer.toHexString(b[n] & 0XFF);
            if (stmp.length() == 1) {
                sb.append("0" + stmp);
            } else {
                sb.append(stmp);
            }


        }
        return sb.toString().toUpperCase();
    }

    /**
     * 保存bitmap到文件夹
     *
     * @param bmp
     * @param username 保存图片名字
     * @param time     当前时间
     * @return
     */
    public static String compressBmpToFile(Bitmap bmp, String username, String time) {
        String savePath = Environment.getExternalStorageDirectory().getAbsolutePath() + "/zfzd/";
        String name = username;

        bmp = AddTimeWatermark(bmp, time);
        boolean dirExists = true;
        File imgDir = new File(savePath);

        if (!imgDir.exists()) {
            dirExists = imgDir.mkdirs();
        }
        if (!dirExists) {
            return "";
        }
        File filePic;
        filePic = new File(savePath + name + ".jpg");
        if (!filePic.exists()) {
            filePic.getParentFile().mkdirs();
            try {
                filePic.createNewFile();
                ByteArrayOutputStream baos = new ByteArrayOutputStream();
                int options = 80;
                bmp.compress(Bitmap.CompressFormat.JPEG, options, baos);
                while (baos.toByteArray().length / 1024 > 40) {
                    baos.reset();
                    options -= 10;
                    bmp.compress(Bitmap.CompressFormat.JPEG, options, baos);
                }
                FileOutputStream fos = new FileOutputStream(filePic);
                fos.write(baos.toByteArray());
                fos.flush();
                fos.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return filePic.getAbsolutePath();

    }

    /**
     * 保存打卡图片并压缩到40kb一下
     *
     * @param image
     * @param username
     * @return
     */
    public static String saveAttendBitmap(Bitmap image, String username) {
        String savePath = Environment.getExternalStorageDirectory().getAbsolutePath() + "/zfzd/";
        String name = username;
        boolean dirExists = true;
        File imgDir = new File(savePath);
        if (!imgDir.exists()) {
            dirExists = imgDir.mkdirs();
        }
        if (!dirExists) {
            return "";
        }
        File filePic;
        try {
            filePic = new File(savePath + name + ".jpg");
            if (!filePic.exists()) {
                filePic.getParentFile().mkdirs();
                filePic.createNewFile();
            }
            ByteArrayOutputStream baos = new ByteArrayOutputStream();
            if (baos == null) {
                return "";
            }
            image.compress(Bitmap.CompressFormat.JPEG, 100, baos);// 质量压缩方法，这里100表示不压缩，把压缩后的数据存放到baos中
            int options = 90;

            while (baos.toByteArray().length / 1024 > 50) { // 循环判断如果压缩后图片是否大于100kb,大于继续压缩
                baos.reset(); // 重置baos即清空baos
                image.compress(Bitmap.CompressFormat.JPEG, options, baos);//
// 这里压缩options%，把压缩后的数据存放到baos中
                if (options > 10) {//设置最小值，防止低于0时出异常
                    options -= 10;// 每次都减少10
                    Log.d(TAG, "saveAttendBitmap: option " + options);
                }
            }
            ByteArrayInputStream isBm = new ByteArrayInputStream(baos.toByteArray());//
// 把压缩后的数据baos存放到ByteArrayInputStream中
            Bitmap bitmap = BitmapFactory.decodeStream(isBm, null, null);//
            FileOutputStream fos = new FileOutputStream(filePic);
            bitmap.compress(Bitmap.CompressFormat.JPEG, 100, fos);
            fos.flush();
            fos.close();
            Log.d(TAG, "saveAttendBitmap:  " + filePic.getAbsolutePath());
        } catch (IOException e) {
            e.printStackTrace();
            Log.d("xxx", "saveBitmap: 2return");
            return null;
        }

        return filePic.getAbsolutePath();
    }

    //删除文件或文件夹
    public static boolean delete(String delFile) {
        File file = new File(delFile);
        if (!file.exists()) {
//            Toast.makeText(getApplicationContext(), "删除文件失败:" + delFile + "不存在！", Toast.LENGTH_SHORT).show();
            Log.d(TAG, "delete: 删除文件夹失败 " + delFile + "不存在");
            return false;
        } else {
            if (file.isFile()) {
                return deleteSingleFile(delFile);
            } else {
                return deleteDirectory(delFile);
            }
        }
    }


    /**
     * 删除单个文件
     *
     * @param filePath$Name 要删除的文件的文件名
     * @return 单个文件删除成功返回true，否则返回false
     */
    public static boolean deleteSingleFile(String filePath$Name) {
        File file = new File(filePath$Name);
        // 如果文件路径所对应的文件存在，并且是一个文件，则直接删除
        if (file.exists() && file.isFile()) {
            if (file.delete()) {
                Log.e("--Method--", "Copy_Delete.deleteSingleFile: 删除单个文件" + filePath$Name + "成功！");
                return true;
            } else {
//                Toast.makeText(getApplicationContext(), "删除单个文件" + filePath$Name + "失败！", Toast.LENGTH_SHORT).show();
                Log.e(TAG, "deleteSingleFile: 删除单个文件" + filePath$Name + "失败");
                return false;
            }
        } else {
            Log.e(TAG, "deleteSingleFile: 删除单个文件" + filePath$Name + "不存在");
            return false;
        }
    }

    /**
     * 删除目录及目录下的文件
     *
     * @param filePath 要删除的目录的文件路径
     * @return 目录删除成功返回true，否则返回false
     */
    public static boolean deleteDirectory(String filePath) {
        // 如果dir不以文件分隔符结尾，自动添加文件分隔符
        if (!filePath.endsWith(File.separator))
            filePath = filePath + File.separator;
        File dirFile = new File(filePath);
        // 如果dir对应的文件不存在，或者不是一个目录，则退出
        if ((!dirFile.exists()) || (!dirFile.isDirectory())) {
            Log.d(TAG, "deleteDirectory: 删除目录失败：" + filePath + "不存在！");
            return false;
        }
        boolean flag = true;
        // 删除文件夹中的所有文件包括子目录
        File[] files = dirFile.listFiles();
        for (File file : files) {
            // 删除子文件
            if (file.isFile()) {
                flag = deleteSingleFile(file.getAbsolutePath());
                if (!flag)
                    break;
            }
            // 删除子目录
            else if (file.isDirectory()) {
                flag = deleteDirectory(file
                        .getAbsolutePath());
                if (!flag)
                    break;
            }
        }
        if (!flag) {
            Log.d(TAG, "deleteDirectory: 删除目录失败：");
            return false;
        }
        // 删除当前目录
        if (dirFile.delete()) {
            Log.e("--Method--", "Copy_Delete.deleteDirectory: 删除目录" + filePath + "成功！");
            return true;
        } else {
            Log.d(TAG, "deleteDirectory: 删除目录：" + filePath + "失败！");
            return false;
        }
    }

    //camera 返回nv21数据转bitmap
    public static Bitmap NV21ToBitmap(byte[] nv21, Camera.Size size) {
        YuvImage image = new YuvImage(nv21, ImageFormat.NV21, size.width, size.height, null);
        Bitmap bitmap = null;
        if (image != null) {
            try {
                ByteArrayOutputStream stream = new ByteArrayOutputStream();
                image.compressToJpeg(new Rect(0, 0, size.width, size.height), 80, stream);
                bitmap = BitmapFactory.decodeByteArray(stream.toByteArray(), 0, stream.size());
                stream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return bitmap;
    }

    /**
     * 获取图片文件的信息，是否旋转了90度，如果是则反转
     *
     * @param bitmap 需要旋转的图片
     * @param path   图片的路径
     */
    public static Bitmap reviewPicRotate(Bitmap bitmap, String path) {
        int degree = getPicRotate(path);
        if (degree != 0) {
            Matrix m = new Matrix();
            int width = bitmap.getWidth();
            int height = bitmap.getHeight();
            m.setRotate(degree); // 旋转angle度
            bitmap = Bitmap.createBitmap(bitmap, 0, 0, width, height, m, true);// 从新生成图片
        }
        return bitmap;
    }
    /**
     * 读取图片文件旋转的角度
     *
     * @param path 图片绝对路径
     * @return 图片旋转的角度
     */
    public static int getPicRotate(String path) {
        int degree = 0;
        try {
            ExifInterface exifInterface = new ExifInterface(path);
            int orientation = exifInterface.getAttributeInt(
                    ExifInterface.TAG_ORIENTATION, ExifInterface.ORIENTATION_NORMAL
            );
            switch (orientation) {
                case ExifInterface.ORIENTATION_ROTATE_90:
                    degree = 90;
                    break;
                case ExifInterface.ORIENTATION_ROTATE_180:
                    degree = 180;
                    break;
                case ExifInterface.ORIENTATION_ROTATE_270:
                    degree = 270;
                    break;
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
        return degree;
    }
    /**
     * 计算图片的压缩比例；
     *
     * @param options   图片处理
     * @param reqWidth  压缩的宽度
     * @param reqHeight 压缩的高度；
     */
    public static int calculateInSampleSize(BitmapFactory.Options options, int reqWidth,
                                            int reqHeight) {
        final int height = options.outHeight;
        final int width = options.outWidth;
        int inSampleSize = 1;

        if (height > reqHeight || width > reqWidth) {
            final int heightRatio = Math.round((float) height / (float) reqHeight);
            final int widthRatio = Math.round((float) width / (float) reqWidth);
            LogUtils.i("heightRatio:" + ((float) height / (float) reqHeight)
                    + "\nwidthRatio:" + ((float) width / (float) reqWidth));
//            inSampleSize = heightRatio > widthRatio ? heightRatio : widthRatio;
            //去缩放更小的那个：
            inSampleSize = heightRatio < widthRatio ? heightRatio : widthRatio;
        }
        // 保证size为1 、2、 4 这样的数，因为3 、5 之类会有异常。
        if (inSampleSize > 1 && inSampleSize % 2 != 0) {
            inSampleSize = inSampleSize - 1;
        }

        return inSampleSize;
    }
    /**
     * 压缩图片
     *
     * @param filePath 传入要压缩的图片的路径
     * @param width    目标width
     * @param height   目标height
     * @return
     * @throws IOException
     */
    public static Bitmap getSmallBitmap(String filePath, int width, int height) throws IOException {
        final BitmapFactory.Options options = new BitmapFactory.Options();
        options.inJustDecodeBounds = true;
        BitmapFactory.decodeFile(filePath, options);

        // Calculate inSampleSize
        options.inSampleSize = calculateInSampleSize(options, width, height);

        // Decode bitmap with inSampleSize set
        options.inJustDecodeBounds = false;
        options.inPreferredConfig = Bitmap.Config.ARGB_8888;
        File file = new File(filePath);
        FileInputStream fs = null;
        try {
            fs = new FileInputStream(file);
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }
        assert fs != null;
        Bitmap bitmap = BitmapFactory.decodeFileDescriptor(
                fs.getFD(), null, options
        );
        // Bitmap bitmap = BitmapFactory.decodeFile(filePath, options);
        if (bitmap == null) {
            return null;
        }
        // bitmap = reviewPicRotate(bitmap, filePath);

        ByteArrayOutputStream baos = null;
        try {
            baos = new ByteArrayOutputStream();
            // 处理图片 可修改保存格式和 质量
            bitmap.compress(Bitmap.CompressFormat.PNG, 100, baos);
        } finally {
            try {
                if (baos != null) baos.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return bitmap;
    }
    /**
     * 压缩图片
     *
     * @param filePath 传入要压缩的图片的路径
     * @param size     要压缩的大小
     * @return
     */
    public static Bitmap getSmallBitmap(String filePath, int size) {
        final BitmapFactory.Options options = new BitmapFactory.Options();
        options.inJustDecodeBounds = true;
        BitmapFactory.decodeFile(filePath, options);

        // Calculate inSampleSize
        options.inSampleSize = size;
        Log.i("Bitmap", "--" + options.inSampleSize);
        // Decode bitmap with inSampleSize set
        options.inJustDecodeBounds = false;
        options.inPreferredConfig = Bitmap.Config.ARGB_8888;
        File file = new File(filePath);
        FileInputStream fs = null;
        try {
            fs = new FileInputStream(file);
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }
        Bitmap bitmap = null;
        try {
            bitmap = BitmapFactory.decodeFileDescriptor(
                    fs.getFD(), null, options
            );
        } catch (IOException e1) {
            e1.printStackTrace();
        }
        //    Bitmap bitmap = BitmapFactory.decodeFile(filePath, options);
        if (bitmap == null) {
            return null;
        }
        // 可选
        // bitmap = reviewPicRotate(bitmap, filePath);

        ByteArrayOutputStream baos = null;
        try {
            baos = new ByteArrayOutputStream();
            // 可定义
            bitmap.compress(Bitmap.CompressFormat.JPEG, 75, baos);
        } finally {
            try {
                if (baos != null) baos.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return bitmap;
    }
    /**
     * @param resources 传入Resources
     * @param resid     资源ID
     * @param size      要压缩的大小
     * @return
     */
    public static Bitmap getSmallBitmap(Resources resources, int resid, int size) {
        final BitmapFactory.Options options = new BitmapFactory.Options();
        options.inJustDecodeBounds = true;
        BitmapFactory.decodeResource(resources, resid, options);

        // Calculate inSampleSize
        options.inSampleSize = size;
        Log.i("Bitmap", "--" + options.inSampleSize);
        // Decode bitmap with inSampleSize set
        options.inJustDecodeBounds = false;
        options.inPreferredConfig = Bitmap.Config.ARGB_8888;
        Bitmap bitmap = BitmapFactory.decodeResource(resources, resid, options);
        if (bitmap == null) {
            return null;
        }
        ByteArrayOutputStream baos = null;
        try {
            baos = new ByteArrayOutputStream();
            bitmap.compress(Bitmap.CompressFormat.JPEG, 100, baos);
        } finally {
            try {
                if (baos != null) baos.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return bitmap;
    }
    /**
     * @param resources 传入Resources
     * @param resid     资源ID
     * @param width     目标width
     * @param height    目标height
     * @return
     */
    public static Bitmap getSmallBitmap(Resources resources, int resid, int width, int height) {
        final BitmapFactory.Options options = new BitmapFactory.Options();
        options.inJustDecodeBounds = true;
        BitmapFactory.decodeResource(resources, resid, options);

        // Calculate inSampleSize
        options.inSampleSize = calculateInSampleSize(options, width, height);
        Log.i("Bitmap", "--" + options.inSampleSize);
        // Decode bitmap with inSampleSize set
        options.inJustDecodeBounds = false;
        options.inPreferredConfig = Bitmap.Config.ARGB_8888;
        Bitmap bitmap = BitmapFactory.decodeResource(resources, resid, options);
        if (bitmap == null) {
            return null;
        }
        ByteArrayOutputStream baos = null;
        try {
            baos = new ByteArrayOutputStream();
            bitmap.compress(Bitmap.CompressFormat.JPEG, 100, baos);
        } finally {
            try {
                if (baos != null) baos.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return bitmap;
    }
    /**
     * 画一个圆角图
     */
    public static Bitmap getRoundedCornerBitmap(Bitmap bitmap, float roundPx) {
        Bitmap output = Bitmap.createBitmap(
                bitmap.getWidth(), bitmap.getHeight(), Bitmap.Config.ARGB_8888
        );
        Canvas canvas = new Canvas(output);
        final int color = 0xff424242;
        final Paint paint = new Paint();
        final Rect rect = new Rect(0, 0, bitmap.getWidth(), bitmap.getHeight());
        final RectF rectF = new RectF(rect);
        paint.setAntiAlias(true);
        canvas.drawARGB(0, 0, 0, 0);
        paint.setColor(color);
        canvas.drawRoundRect(rectF, roundPx, roundPx, paint);
        paint.setXfermode(new PorterDuffXfermode(PorterDuff.Mode.SRC_IN));
        canvas.drawBitmap(bitmap, rect, rect, paint);
        return output;
    }
    /**
     * 缩放Bitmap图片
     **/
    public static Bitmap zoomBitmap(Bitmap bitmap, int width, int height) {
        int w = bitmap.getWidth();
        int h = bitmap.getHeight();
        Matrix matrix = new Matrix();
        float scaleWidth = ((float) width / w);
        float scaleHeight = ((float) height / h);
        matrix.postScale(scaleWidth, scaleHeight);// 利用矩阵进行缩放不会造成内存溢出
        Bitmap newbmp = Bitmap.createBitmap(bitmap, 0, 0, w, h, matrix, true);
        return newbmp;
    }

    /**
     * 转换图片成圆形
     *
     * @param bitmap 传入Bitmap对象
     */
    public static Bitmap toRoundBitmap(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;
        }

        Bitmap output = Bitmap.createBitmap(width, height, Bitmap.Config.ARGB_8888);
        Canvas canvas = new Canvas(output);

        final int 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(new PorterDuffXfermode(PorterDuff.Mode.SRC_IN));
        canvas.drawBitmap(bitmap, src, dst, paint);
        return output;
    }
}