图片宽度、高度、uri转path、图片旋转角度、矩形框、摄像头Camera

//在图片上画矩形框
private Bitmap drawRectangles(Bitmap imageBitmap,int left,int top,int right,int bottom) {
        Bitmap mutableBitmap = imageBitmap.copy(Bitmap.Config.ARGB_8888, true);
        Canvas canvas = new Canvas(mutableBitmap);//准备一个画板，在上面放上准备好的空白的位图
        Paint paint = new Paint();//准备一个画笔
        paint.setColor(Color.RED);
        paint.setStyle(Paint.Style.STROKE);//不填充
        paint.setStrokeWidth(10); //线的宽度
        canvas.drawRect(left,top,right,bottom,paint);
        return mutableBitmap;
    }

//获取照片的宽度
//imagePath是绝对路径
  private int getImageWidth(String imagePath){
        BitmapFactory.Options options = new BitmapFactory.Options();
        Bitmap bitmap = BitmapFactory.decodeFile(imagePath,options);
        int width=options.outWidth;
        Log.d("MainActivity","width="+width);
        return width;
    }

//获取照片的高度
//imagePath是绝对路径
    private int getImageHeight(String imagePath){
        BitmapFactory.Options options = new BitmapFactory.Options();
        Bitmap bitmap = BitmapFactory.decodeFile(imagePath,options);
        int height=options.outHeight;
        Log.d("MainActivity","ImageHeight="+height);
        return height;
    }

//uri来源 imageUri
if(Build.VERSION.SDK_INT>=24){
                    imageUri= FileProvider.getUriForFile(MainActivity.this,
                            "com.example.AARinput.fileprovider",outputImage);
                }else{
                    imageUri=Uri.fromFile(outputImage);
                }

//文件的uri路径转成绝对路径
public static String uriToPath( final Context context, final Uri uri ) {
        if ( null == uri ) return null;
        final String scheme = uri.getScheme();
        String data = null;
        if ( scheme == null )
            data = uri.getPath();
        else if ( ContentResolver.SCHEME_FILE.equals( scheme ) ) {
            data = uri.getPath();
        } else if ( ContentResolver.SCHEME_CONTENT.equals( scheme ) ) {
            Cursor cursor = context.getContentResolver().query( uri, new String[] { MediaStore.Images.ImageColumns.DATA }, null, null, null );
            if ( null != cursor ) {
                if ( cursor.moveToFirst() ) {
                    int index = cursor.getColumnIndex( MediaStore.Images.ImageColumns.DATA );
                    if ( index > -1 ) {
                        data = cursor.getString( index );
                    }
                }
                cursor.close();
            }
        }
        return data;
    }

/**
     * 获取图片的旋转角度。
     * 只能通过原始文件获取，如果已经进行过bitmap操作无法获取。
     */
    private static int getRotateDegree(String path) {
        int result = 0;
        try {
            ExifInterface exif = new ExifInterface(path);
            int orientation = exif.getAttributeInt(
                    ExifInterface.TAG_ORIENTATION,
                    ExifInterface.ORIENTATION_NORMAL);
            switch (orientation) {
                case ExifInterface.ORIENTATION_ROTATE_90:
                    result = 90;
                    break;
                case ExifInterface.ORIENTATION_ROTATE_180:
                    result = 180;
                    break;
                case ExifInterface.ORIENTATION_ROTATE_270:
                    result = 270;
                    break;
            }
        } catch (IOException ignore) {
            return 0;
        }
        Log.d("MainActivity","result="+result);
        return result;
    }

//将NV21格式的图片保存为 .jpg
private void saveAImg(){
        imgThread=new Thread(){
            @Override
            public void run() {
                Log.d(TAG,"开始保存图像");
                //保存一张照片
                String fileName = "IMG_test"+".jpg" ;  //jpeg文件名定义
                File sdRoot = Environment.getExternalStorageDirectory();    //系统路径
                File pictureFile = new File(sdRoot, fileName);
                if (!pictureFile.exists()) {
                    try {
                        pictureFile.createNewFile();
                        FileOutputStream filecon = new FileOutputStream(pictureFile);
                        YuvImage image = new YuvImage(mBuffer, ImageFormat.NV21,mPreviewWidth, mPreviewHeight, null);   //将NV21 data保存成YuvImage
                        //图像压缩
                        image.compressToJpeg(
                                new Rect(0, 0, image.getWidth(), image.getHeight()),
                               70， filecon);
                        filecon.close();
                        Log.d(TAG,"图片保存成功!");
                    }catch (IOException e)
                    {
                        e.printStackTrace();
                    }
                }

            }
        };
        imgThread.start();
        try{
            imgThread.join();
        }catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

//获取存储的图像的绝对路径
private String getFilePath(String Filename){
        File file=new File(Environment.getExternalStorageDirectory(),Filename);
        Log.d("MainActivity.this","Img Path= "+file.getPath());
        return file.getPath();
    }

//设置摄像头参数，mCamera是自己new的Camera实例
 private void initParameters() {
        if (mCamera == null) {
            return;
        }
        try {
            Camera.Parameters parameters = mCamera.getParameters();
            // 如果摄像头不支持这些参数都会出错的，所以设置的时候一定要判断是否支持
            List<String> supportedFlashModes = parameters.getSupportedFlashModes();
            if (supportedFlashModes != null && supportedFlashModes.contains(Camera.Parameters.FLASH_MODE_OFF)) {
                // 设置闪光模式
                parameters.setFlashMode(Camera.Parameters.FLASH_MODE_OFF);
            }
            List<String> supportedFocusModes = parameters.getSupportedFocusModes();
            if (supportedFocusModes != null && supportedFocusModes.contains(Camera.Parameters.FOCUS_MODE_AUTO)) {
                // 设置聚焦模式
                parameters.setFocusMode(Camera.Parameters.FOCUS_MODE_AUTO);
            }
            // 设置预览图片格式
            parameters.setPreviewFormat(NV21);
            // 设置拍照图片格式
            parameters.setPictureFormat(ImageFormat.JPEG);
            // 将设置好的parameters添加到相机里
            mCamera.setParameters(parameters);
            initPreviewSize();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

/**
     * 初始化预览尺寸大小并设置，根据拉伸比例、分辨率来计算
     */
    private void initPreviewSize() {
        if (mCamera == null) {
            return;
        }
        Camera.Parameters parameters = mCamera.getParameters();
        // 获取适合的预览大小
        mPreviewSize = getFitPreviewSize(parameters);
        mPreviewWidth = mPreviewSize.width;
        mPreviewHeight = mPreviewSize.height;
        // 设置预览图片大小
        parameters.setPreviewSize(mPreviewWidth, mPreviewHeight);
        if (DEBUG) {
            Log.d(TAG, "initPreviewSize() mPreviewWidth: " + mPreviewWidth + ", mPreviewHeight: " + mPreviewHeight);
        }
        mCamera.setParameters(parameters);
    }

    /**
     * 具体计算最佳分辨率大小的方法
     */
    private Camera.Size getFitPreviewSize(Camera.Parameters parameters) {
        // 获取支持的预览尺寸大小
        List<Camera.Size> previewSizes = parameters.getSupportedPreviewSizes();
        // 最小的差值，初始值应该设置大点保证之后的计算中会被重置
        int minDelta = Integer.MAX_VALUE;
        // 最小的差值对应的索引坐标
        int index = 0;
        for (int i = 0; i < previewSizes.size(); i++) {
            Camera.Size previewSize = previewSizes.get(i);
            if (DEBUG) {
                Log.d(TAG, "SupportedPreviewSize, width: " + previewSize.width + ", height: " + previewSize.height);
            }
            // 找到一个与设置的分辨率差值最小的相机支持的分辨率大小
            if (Math.abs(previewSize.width * mPreviewScale - previewSize.height) < .0000001F) {
                int delta = Math.abs(mResolution - previewSize.height);
                if (delta == 0) {
                    return previewSize;
                }
                if (minDelta > delta) {
                    minDelta = delta;
                    index = i;
                }
            }
        }
        // 默认返回与设置的分辨率最接近的预览尺寸
        return previewSizes.get(index);
    }