devbox
weixin_40725706
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

Android 自定义相机实现身份证拍照，并加入自动对焦与图片不规则裁剪

作者：weixin_40725706 | 2024-06-06 23:26:01

赞

踩

koltlin自定义身份证相机

一、 前言

前段时间，应公司要求实现一个自定义相机，需要有自动对焦和图片不规则裁剪功能，其实难点主要也是这2个功能。经Google搜索，发现并没有现成的轮子。最后通过各种查找资料，自己封装了一个，效果图如下：

身份证来源网络虚拟构造

二、使用

Step 1. 添加JitPack仓库
在项目的build.gradle添加JitPack仓库

  1. allprojects{
  2.     repositories {
  3.         ...
  4.         maven { url "https://jitpack.io" }
  5.     }
  6. }

Step 2. 添加依赖
在需要使用的module中添加依赖（最新版本见 WildmaIDCardCamera）

  1. dependencies{
  2.     compile 'com.github.wildma:IDCardCamera:1.0.1'
  3. }

或者引用本地lib

compileproject(':idcardcamera')

Step 3. 调用CameraActivity类的toCameraActivity方法打开拍照界面

CameraActivity.toCameraActivity(this, CameraActivity.TYPE_IDCARD_FRONT);

Step 4. 在onActivityResult方法中获取裁剪后的图片

  1. @Override
  2.     protected void onActivityResult(int requestCode, int resultCode, Intent data) {
  3.         if (requestCode == CameraActivity.REQUEST_CODE && resultCode == CameraActivity.RESULT_CODE) {
  4.             //获取图片路径，显示图片
  5.             final String path = CameraActivity.getImagePath(data);
  6.             if (!TextUtils.isEmpty(path)) {
  7.                 imageView.setImageBitmap(BitmapFactory.decodeFile(path));
  8.             }
  9.         }
  10.     }

三、功能特点

自定义相机的代码我就不重复造轮子了，网上很多，我找了个UI比较不错的项目 CertificateCamera ，然后在该项目的基础上进行功能增加的，主要增加的内容如下：

  1. 解决该项目拍照不成功的问题（该项目代码有问题，博主也一直没有去修改，这里帮他改过来了）
  2. 增加自动对焦功能
  3. 增加图片不规则裁剪功能

3.1 自动对焦

实现自动对焦有多种方式，这里列举下：

3.1.1 使用原生API

  1. 调用autoFocus方法，如下：

    1. camera.autoFocus(new Camera.AutoFocusCallback() {
    2.          @Override
    3.          public void onAutoFocus(boolean success, Camera camera) {
    4.          }
    5.      });

    结论：不满足，大部分手机只对焦一次。

  2. 设置对焦模式，如下：

    camera.getParameters().setFocusMode(Camera.Parameters.FOCUS_MODE_CONTINUOUS_PICTURE);

    或

    camera.getParameters().setFocusMode(Camera.Parameters.FOCUS_MODE_CONTINUOUS_VIDEO);

    结论：不满足，不能兼容所有手机。

3.1.2 使用定时器

即使用一个定时器，每隔一段时间进行自动对焦。代码如下：

  1. package com.wildma.idcardcamera.camera;
  2.  
  3. import android.annotation.SuppressLint;
  4. import android.hardware.Camera;
  5. import android.os.AsyncTask;
  6. import android.os.Build;
  7. import android.util.Log;
  8.  
  9. import java.util.ArrayList;
  10. import java.util.Collection;
  11. import java.util.concurrent.RejectedExecutionException;
  12.  
  13. public class AutoFocusManager implements Camera.AutoFocusCallback {
  14.  
  15.     private static final String TAG = AutoFocusManager.class.getSimpleName();
  16.  
  17.     private static final long AUTO_FOCUS_INTERVAL_MS = 2000L;
  18.     private static final Collection<String> FOCUS_MODES_CALLING_AF;
  19.  
  20.     static {
  21.         FOCUS_MODES_CALLING_AF = new ArrayList<String>(2);
  22.         FOCUS_MODES_CALLING_AF.add(Camera.Parameters.FOCUS_MODE_AUTO);
  23.         FOCUS_MODES_CALLING_AF.add(Camera.Parameters.FOCUS_MODE_MACRO);
  24.     }
  25.  
  26.     private final boolean            useAutoFocus;
  27.     private final Camera             camera;
  28.     private       boolean            stopped;
  29.     private       boolean            focusing;
  30.     private       AsyncTask<?, ?, ?> outstandingTask;
  31.  
  32.     public AutoFocusManager(Camera camera) {
  33.         this.camera = camera;
  34.         String currentFocusMode = camera.getParameters().getFocusMode();
  35.         useAutoFocus = FOCUS_MODES_CALLING_AF.contains(currentFocusMode);
  36.         //  Log.i(TAG, "Current focus mode '" + currentFocusMode + "'; use auto focus? " + useAutoFocus);
  37.         start();
  38.     }
  39.  
  40.     @Override
  41.     public synchronized void onAutoFocus(boolean success, Camera theCamera) {
  42.         focusing = false;
  43.         autoFocusAgainLater();
  44.     }
  45.  
  46.     @SuppressLint("NewApi")
  47.     private synchronized void autoFocusAgainLater() {
  48.         if (!stopped && outstandingTask == null) {
  49.             AutoFocusTask newTask = new AutoFocusTask();
  50.             try {
  51.                 if (Build.VERSION.SDK_INT >= 11) {
  52.                     newTask.executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR);
  53.                 } else {
  54.                     newTask.execute();
  55.                 }
  56.                 outstandingTask = newTask;
  57.             } catch (RejectedExecutionException ree) {
  58.                 Log.w(TAG, "Could not request auto focus", ree);
  59.             }
  60.         }
  61.     }
  62.  
  63.     public synchronized void start() {
  64.         if (useAutoFocus) {
  65.             outstandingTask = null;
  66.             if (!stopped && !focusing) {
  67.                 try {
  68.                     camera.autoFocus(this);
  69.                     Log.w(TAG, "自动对焦");
  70.                     focusing = true;
  71.                 } catch (RuntimeException re) {
  72.                     // Have heard RuntimeException reported in Android 4.0.x+;
  73.                     // continue?
  74.                     Log.w(TAG, "Unexpected exception while focusing", re);
  75.                     // Try again later to keep cycle going
  76.                     autoFocusAgainLater();
  77.                 }
  78.             }
  79.         }
  80.     }
  81.  
  82.     private synchronized void cancelOutstandingTask() {
  83.         if (outstandingTask != null) {
  84.             if (outstandingTask.getStatus() != AsyncTask.Status.FINISHED) {
  85.                 outstandingTask.cancel(true);
  86.             }
  87.             outstandingTask = null;
  88.         }
  89.     }
  90.  
  91.     public synchronized void stop() {
  92.         stopped = true;
  93.         if (useAutoFocus) {
  94.             cancelOutstandingTask();
  95.             // Doesn't hurt to call this even if not focusing
  96.             try {
  97.                 camera.cancelAutoFocus();
  98.             } catch (RuntimeException re) {
  99.                 // Have heard RuntimeException reported in Android 4.0.x+;
  100.                 // continue?
  101.                 Log.w(TAG, "Unexpected exception while cancelling focusing", re);
  102.             }
  103.         }
  104.     }
  105.  
  106.     private final class AutoFocusTask extends AsyncTask<Object, Object, Object> {
  107.         @Override
  108.         protected Object doInBackground(Object... voids) {
  109.             try {
  110.                 Thread.sleep(AUTO_FOCUS_INTERVAL_MS);
  111.             } catch (InterruptedException e) {
  112.             }
  113.             start();
  114.             return null;
  115.         }
  116.     }
  117.  
  118. }

结论：虽然可以实现，但是你对比下手机自带的相机，发现并不是每隔一段时间进行自动对焦的，都是通过移动手机后才自动对焦的，所以这种方式是不合理的。

3.1.3 使用传感器

即根据传感器来判断手机的运动状态，如果手机从静止状态变成运行状态后再次进入静止状态，此时就是手机的对焦时机。代码如下：

  1. package com.wildma.idcardcamera.camera;
  2.  
  3. import android.app.Activity;
  4. import android.content.Context;
  5. import android.hardware.Sensor;
  6. import android.hardware.SensorEvent;
  7. import android.hardware.SensorEventListener;
  8. import android.hardware.SensorManager;
  9. import android.util.Log;
  10.  
  11. import java.util.Calendar;
  12.  
  13. public class SensorControler implements SensorEventListener {
  14.     public static final String TAG = "SensorControler";
  15.     private SensorManager mSensorManager;
  16.     private Sensor        mSensor;
  17.     private int           mX, mY, mZ;
  18.     private long lastStaticStamp = 0;
  19.     Calendar mCalendar;
  20.     public static final int DELEY_DURATION = 500;
  21.     private static SensorControler mInstance;
  22.     private int foucsing = 1;  //1 表示没有被锁定 0表示被锁定
  23.  
  24.     boolean isFocusing = false;
  25.     boolean canFocusIn = false;  //内部是否能够对焦控制机制
  26.     boolean canFocus   = false;
  27.  
  28.     public static final int STATUS_NONE   = 0;
  29.     public static final int STATUS_STATIC = 1;
  30.     public static final int STATUS_MOVE   = 2;
  31.     private             int STATUE        = STATUS_NONE;
  32.  
  33.     private SensorControler(Context context) {
  34.         mSensorManager = (SensorManager) context.getSystemService(Activity.SENSOR_SERVICE);
  35.         mSensor = mSensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER);// TYPE_GRAVITY
  36.     }
  37.  
  38.     public static SensorControler getInstance(Context context) {
  39.         if (mInstance == null) {
  40.             mInstance = new SensorControler(context);
  41.         }
  42.         return mInstance;
  43.     }
  44.  
  45.     public void onStart() {
  46.         restParams();
  47.         canFocus = true;
  48.         mSensorManager.registerListener(this, mSensor,
  49.                 SensorManager.SENSOR_DELAY_NORMAL);
  50.     }
  51.  
  52.     public void onStop() {
  53.         mSensorManager.unregisterListener(this, mSensor);
  54.         canFocus = false;
  55.     }
  56.  
  57.     @Override
  58.     public void onAccuracyChanged(Sensor sensor, int accuracy) {
  59.  
  60.     }
  61.  
  62.     @Override
  63.     public void onSensorChanged(SensorEvent event) {
  64.         if (event.sensor == null) {
  65.             return;
  66.         }
  67.  
  68.         if (isFocusing) {
  69.             restParams();
  70.             return;
  71.         }
  72.  
  73.         if (event.sensor.getType() == Sensor.TYPE_ACCELEROMETER) {
  74.             int x = (int) event.values[0];
  75.             int y = (int) event.values[1];
  76.             int z = (int) event.values[2];
  77.             mCalendar = Calendar.getInstance();
  78.             long stamp = mCalendar.getTimeInMillis();// 1393844912
  79.  
  80.             int second = mCalendar.get(Calendar.SECOND);// 53
  81.  
  82.             if (STATUE != STATUS_NONE) {
  83.                 int px = Math.abs(mX - x);
  84.                 int py = Math.abs(mY - y);
  85.                 int pz = Math.abs(mZ - z);
  86.                 //                Log.d(TAG, "pX:" + px + "  pY:" + py + "  pZ:" + pz + "    stamp:"
  87.                 //                        + stamp + "  second:" + second);
  88.                 double value = Math.sqrt(px * px + py * py + pz * pz);
  89.                 if (value > 1.4) {
  90.                     //                    textviewF.setText("检测手机在移动..");
  91.                     //                    Log.i(TAG,"mobile moving");
  92.                     STATUE = STATUS_MOVE;
  93.                 } else {
  94.                     //                    textviewF.setText("检测手机静止..");
  95.                     //                    Log.i(TAG,"mobile static");
  96.                     //上一次状态是move，记录静态时间点
  97.                     if (STATUE == STATUS_MOVE) {
  98.                         lastStaticStamp = stamp;
  99.                         canFocusIn = true;
  100.                     }
  101.  
  102.                     if (canFocusIn) {
  103.                         if (stamp - lastStaticStamp > DELEY_DURATION) {
  104.                             //移动后静止一段时间，可以发生对焦行为
  105.                             if (!isFocusing) {
  106.                                 canFocusIn = false;
  107.                                 //                                onCameraFocus();
  108.                                 if (mCameraFocusListener != null) {
  109.                                     mCameraFocusListener.onFocus();
  110.                                 }
  111.                                 //                                Log.i(TAG,"mobile focusing");
  112.                             }
  113.                         }
  114.                     }
  115.  
  116.                     STATUE = STATUS_STATIC;
  117.                 }
  118.             } else {
  119.                 lastStaticStamp = stamp;
  120.                 STATUE = STATUS_STATIC;
  121.             }
  122.  
  123.             mX = x;
  124.             mY = y;
  125.             mZ = z;
  126.         }
  127.     }
  128.  
  129.     /**
  130.      * 重置参数
  131.      */
  132.     private void restParams() {
  133.         STATUE = STATUS_NONE;
  134.         canFocusIn = false;
  135.         mX = 0;
  136.         mY = 0;
  137.         mZ = 0;
  138.     }
  139.  
  140.     /**
  141.      * 对焦是否被锁定
  142.      *
  143.      * @return
  144.      */
  145.     public boolean isFocusLocked() {
  146.         if (canFocus) {
  147.             return foucsing <= 0;
  148.         }
  149.         return false;
  150.     }
  151.  
  152.     /**
  153.      * 锁定对焦
  154.      */
  155.     public void lockFocus() {
  156.         isFocusing = true;
  157.         foucsing--;
  158.         Log.i(TAG, "lockFocus");
  159.     }
  160.  
  161.     /**
  162.      * 解锁对焦
  163.      */
  164.     public void unlockFocus() {
  165.         isFocusing = false;
  166.         foucsing++;
  167.         Log.i(TAG, "unlockFocus");
  168.     }
  169.  
  170.     public void restFoucs() {
  171.         foucsing = 1;
  172.     }
  173.  
  174.  
  175.     private CameraFocusListener mCameraFocusListener;
  176.  
  177.     public interface CameraFocusListener {
  178.         void onFocus();
  179.     }
  180.  
  181.     public void setCameraFocusListener(CameraFocusListener mCameraFocusListener) {
  182.         this.mCameraFocusListener = mCameraFocusListener;
  183.     }
  184. }

结论：完美实现，只要带传感器的手机就能兼容。

3.2 图片不规则裁剪

要实现的效果如下：
alt

由效果图可得出如下结论：

  1. 需要利用drawline将四个坐标点连接起来
  2. 需要处理触摸与拖拽事件，即随着手指的移动，坐标点跟随移动。
  3. 需要处理裁剪框区域内的全透明化和区域外的半透明化的效果。
  4. 其他等等…

也就是说需要很强的自定义View的能力和计算能力，所以想着还是找找现成的轮子吧。
经过各种Google，发现国内很难找到这种轮子，最终还是在Github上找了一个国外的，主要代码如下：

  1. package com.wildma.idcardcamera.cropper;
  2.  
  3. import android.content.Context;
  4. import android.graphics.Bitmap;
  5. import android.graphics.Canvas;
  6. import android.graphics.Color;
  7. import android.graphics.Matrix;
  8. import android.graphics.Paint;
  9. import android.graphics.Path;
  10. import android.graphics.Point;
  11. import android.graphics.PorterDuff;
  12. import android.graphics.PorterDuffXfermode;
  13. import android.graphics.Rect;
  14. import android.graphics.Region;
  15. import android.support.annotation.Nullable;
  16. import android.util.AttributeSet;
  17. import android.util.Log;
  18. import android.view.MotionEvent;
  19. import android.view.View;
  20.  
  21. public class CropOverlayView extends View {
  22.  
  23.     private int defaultMargin = 100;
  24.     private int minDistance   = 100;
  25.     private int vertexSize    = 30;
  26.     private int gridSize      = 3;
  27.  
  28.     private Bitmap bitmap;
  29.     private Point  topLeft, topRight, bottomLeft, bottomRight;
  30.  
  31.     private float touchDownX, touchDownY;
  32.     private CropPosition cropPosition;
  33.  
  34.     private int currentWidth  = 0;
  35.     private int currentHeight = 0;
  36.  
  37.     private int minX, maxX, minY, maxY;
  38.  
  39.     public CropOverlayView(Context context) {
  40.         super(context);
  41.     }
  42.  
  43.     public CropOverlayView(Context context, @Nullable AttributeSet attrs) {
  44.         super(context, attrs);
  45.     }
  46.  
  47.     public void setBitmap(Bitmap bitmap) {
  48.         this.bitmap = bitmap;
  49.         resetPoints();
  50.         invalidate();
  51.     }
  52.  
  53.     @Override
  54.     protected void onDraw(Canvas canvas) {
  55.         super.onDraw(canvas);
  56.  
  57.         if (getWidth() != currentWidth || getHeight() != currentHeight) {
  58.             currentWidth = getWidth();
  59.             currentHeight = getHeight();
  60.             resetPoints();
  61.         }
  62.         Log.e("stk", "canvasSize=" + getWidth() + "x" + getHeight());
  63.  
  64.         drawBackground(canvas);
  65.         drawVertex(canvas);
  66.         drawEdge(canvas);
  67.         //        drawGrid(canvas);//裁剪框内部线条
  68.     }
  69.  
  70.     private void resetPoints() {
  71.  
  72.         Log.e("stk", "resetPoints, bitmap=" + bitmap);
  73.  
  74.         // 1. calculate bitmap size in new canvas
  75.         float scaleX = bitmap.getWidth() * 1.0f / getWidth();
  76.         float scaleY = bitmap.getHeight() * 1.0f / getHeight();
  77.         float maxScale = Math.max(scaleX, scaleY);
  78.  
  79.         // 2. determine minX , maxX if maxScale = scaleY | minY, maxY if maxScale = scaleX
  80.         int minX = 0;
  81.         int maxX = getWidth();
  82.         int minY = 0;
  83.         int maxY = getHeight();
  84.  
  85.         if (maxScale == scaleY) { // image very tall
  86.             int bitmapInCanvasWidth = (int) (bitmap.getWidth() / maxScale);
  87.             minX = (getWidth() - bitmapInCanvasWidth) / 2;
  88.             maxX = getWidth() - minX;
  89.         } else { // image very wide
  90.             int bitmapInCanvasHeight = (int) (bitmap.getHeight() / maxScale);
  91.             minY = (getHeight() - bitmapInCanvasHeight) / 2;
  92.             maxY = getHeight() - minY;
  93.         }
  94.  
  95.         this.minX = minX;
  96.         this.minY = minY;
  97.         this.maxX = maxX;
  98.         this.maxY = maxY;
  99.  
  100.         if (maxX - minX < defaultMargin || maxY - minY < defaultMargin)
  101.             defaultMargin = 0; // remove min
  102.         else
  103.             defaultMargin = 100;
  104.  
  105.         Log.e("stk", "maxX - minX=" + (maxX - minX));
  106.         Log.e("stk", "maxY - minY=" + (maxY - minY));
  107.  
  108.         topLeft = new Point(minX + defaultMargin, minY + defaultMargin);
  109.         topRight = new Point(maxX - defaultMargin, minY + defaultMargin);
  110.         bottomLeft = new Point(minX + defaultMargin, maxY - defaultMargin);
  111.         bottomRight = new Point(maxX - defaultMargin, maxY - defaultMargin);
  112.     }
  113.  
  114.     @Override
  115.     protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
  116.         super.onMeasure(widthMeasureSpec, heightMeasureSpec);
  117.     }
  118.  
  119.     private void drawBackground(Canvas canvas) {
  120.         Paint paint = new Paint();
  121.         paint.setColor(Color.parseColor("#66000000"));
  122.         paint.setStyle(Paint.Style.FILL);
  123.  
  124.         Path path = new Path();
  125.         path.moveTo(topLeft.x, topLeft.y);
  126.         path.lineTo(topRight.x, topRight.y);
  127.         path.lineTo(bottomRight.x, bottomRight.y);
  128.         path.lineTo(bottomLeft.x, bottomLeft.y);
  129.         path.close();
  130.  
  131.         canvas.save();
  132.         canvas.clipPath(path, Region.Op.DIFFERENCE);
  133.         canvas.drawColor(Color.parseColor("#66000000"));
  134.         canvas.restore();
  135.     }
  136.  
  137.     private void drawVertex(Canvas canvas) {
  138.         Paint paint = new Paint();
  139.         paint.setColor(Color.WHITE);
  140.         paint.setStyle(Paint.Style.FILL);
  141.  
  142.         canvas.drawCircle(topLeft.x, topLeft.y, vertexSize, paint);
  143.         canvas.drawCircle(topRight.x, topRight.y, vertexSize, paint);
  144.         canvas.drawCircle(bottomLeft.x, bottomLeft.y, vertexSize, paint);
  145.         canvas.drawCircle(bottomRight.x, bottomRight.y, vertexSize, paint);
  146.  
  147.         Log.e("stk",
  148.                 "vertextPoints=" +
  149.                         topLeft.toString() + " " + topRight.toString() + " " + bottomRight.toString() + " " + bottomLeft.toString());
  150.  
  151.     }
  152.  
  153.     private void drawEdge(Canvas canvas) {
  154.         Paint paint = new Paint();
  155.         paint.setColor(Color.WHITE);
  156.         paint.setStrokeWidth(3);
  157.         paint.setAntiAlias(true);
  158.  
  159.         canvas.drawLine(topLeft.x, topLeft.y, topRight.x, topRight.y, paint);
  160.         canvas.drawLine(topLeft.x, topLeft.y, bottomLeft.x, bottomLeft.y, paint);
  161.         canvas.drawLine(bottomRight.x, bottomRight.y, topRight.x, topRight.y, paint);
  162.         canvas.drawLine(bottomRight.x, bottomRight.y, bottomLeft.x, bottomLeft.y, paint);
  163.     }
  164.  
  165.     private void drawGrid(Canvas canvas) {
  166.         Paint paint = new Paint();
  167.         paint.setColor(Color.WHITE);
  168.         paint.setStrokeWidth(2);
  169.         paint.setAntiAlias(true);
  170.  
  171.         for (int i = 1; i <= gridSize; i++) {
  172.             int topDistanceX = Math.abs(topLeft.x - topRight.x) / (gridSize + 1) * i;
  173.             int topDistanceY = Math.abs((topLeft.y - topRight.y) / (gridSize + 1) * i);
  174.  
  175.             Point top = new Point(
  176.                     topLeft.x < topRight.x ? topLeft.x + topDistanceX : topLeft.x - topDistanceX,
  177.                     topLeft.y < topRight.y ? topLeft.y + topDistanceY : topLeft.y - topDistanceY);
  178.  
  179.             int bottomDistanceX = Math.abs((bottomLeft.x - bottomRight.x) / (gridSize + 1) * i);
  180.             int bottomDistanceY = Math.abs((bottomLeft.y - bottomRight.y) / (gridSize + 1) * i);
  181.             Point bottom = new Point(
  182.                     bottomLeft.x < bottomRight.x ? bottomLeft.x + bottomDistanceX : bottomLeft.x - bottomDistanceX,
  183.                     bottomLeft.y < bottomRight.y ? bottomLeft.y + bottomDistanceY : bottomLeft.y - bottomDistanceY);
  184.  
  185.             canvas.drawLine(top.x, top.y, bottom.x, bottom.y, paint);
  186.  
  187.             int leftDistanceX = Math.abs((topLeft.x - bottomLeft.x) / (gridSize + 1) * i);
  188.             int leftDistanceY = Math.abs((topLeft.y - bottomLeft.y) / (gridSize + 1) * i);
  189.  
  190.             Point left = new Point(
  191.                     topLeft.x < bottomLeft.x ? topLeft.x + leftDistanceX : topLeft.x - leftDistanceX,
  192.                     topLeft.y < bottomLeft.y ? topLeft.y + leftDistanceY : topLeft.y - leftDistanceY);
  193.  
  194.             int rightDistanceX = Math.abs((topRight.x - bottomRight.x) / (gridSize + 1) * i);
  195.             int rightDistanceY = Math.abs((topRight.y - bottomRight.y) / (gridSize + 1) * i);
  196.  
  197.             Point right = new Point(
  198.                     topRight.x < bottomRight.x ? topRight.x + rightDistanceX : topRight.x - rightDistanceX,
  199.                     topRight.y < bottomRight.y ? topRight.y + rightDistanceY : topRight.y - rightDistanceY);
  200.  
  201.             canvas.drawLine(left.x, left.y, right.x, right.y, paint);
  202.         }
  203.  
  204.     }
  205.  
  206.     @Override
  207.     public boolean onTouchEvent(MotionEvent event) {
  208.         switch (event.getAction()) {
  209.             case MotionEvent.ACTION_UP:
  210.                 getParent().requestDisallowInterceptTouchEvent(false);
  211.                 break;
  212.             case MotionEvent.ACTION_DOWN:
  213.                 getParent().requestDisallowInterceptTouchEvent(false);
  214.                 onActionDown(event);
  215.                 return true;
  216.             case MotionEvent.ACTION_MOVE:
  217.                 getParent().requestDisallowInterceptTouchEvent(true);
  218.                 onActionMove(event);
  219.                 return true;
  220.         }
  221.         return false;
  222.     }
  223.  
  224.     private void onActionDown(MotionEvent event) {
  225.         touchDownX = event.getX();
  226.         touchDownY = event.getY();
  227.         Point touchPoint = new Point((int) event.getX(), (int) event.getY());
  228.         int minDistance = distance(touchPoint, topLeft);
  229.         cropPosition = CropPosition.TOP_LEFT;
  230.         if (minDistance > distance(touchPoint, topRight)) {
  231.             minDistance = distance(touchPoint, topRight);
  232.             cropPosition = CropPosition.TOP_RIGHT;
  233.         }
  234.         if (minDistance > distance(touchPoint, bottomLeft)) {
  235.             minDistance = distance(touchPoint, bottomLeft);
  236.             cropPosition = CropPosition.BOTTOM_LEFT;
  237.         }
  238.         if (minDistance > distance(touchPoint, bottomRight)) {
  239.             minDistance = distance(touchPoint, bottomRight);
  240.             cropPosition = CropPosition.BOTTOM_RIGHT;
  241.         }
  242.     }
  243.  
  244.     private int distance(Point src, Point dst) {
  245.         return (int) Math.sqrt(Math.pow(src.x - dst.x, 2) + Math.pow(src.y - dst.y, 2));
  246.     }
  247.  
  248.     private void onActionMove(MotionEvent event) {
  249.         int deltaX = (int) (event.getX() - touchDownX);
  250.         int deltaY = (int) (event.getY() - touchDownY);
  251.  
  252.         switch (cropPosition) {
  253.             case TOP_LEFT:
  254.                 adjustTopLeft(deltaX, deltaY);
  255.                 invalidate();
  256.                 break;
  257.             case TOP_RIGHT:
  258.                 adjustTopRight(deltaX, deltaY);
  259.                 invalidate();
  260.                 break;
  261.             case BOTTOM_LEFT:
  262.                 adjustBottomLeft(deltaX, deltaY);
  263.                 invalidate();
  264.                 break;
  265.             case BOTTOM_RIGHT:
  266.                 adjustBottomRight(deltaX, deltaY);
  267.                 invalidate();
  268.                 break;
  269.         }
  270.         touchDownX = event.getX();
  271.         touchDownY = event.getY();
  272.     }
  273.  
  274.     private void adjustTopLeft(int deltaX, int deltaY) {
  275.         int newX = topLeft.x + deltaX;
  276.         if (newX < minX)
  277.             newX = minX;
  278.         if (newX > maxX)
  279.             newX = maxX;
  280.  
  281.         int newY = topLeft.y + deltaY;
  282.         if (newY < minY)
  283.             newY = minY;
  284.         if (newY > maxY)
  285.             newY = maxY;
  286.  
  287.         topLeft.set(newX, newY);
  288.     }
  289.  
  290.     private void adjustTopRight(int deltaX, int deltaY) {
  291.         int newX = topRight.x + deltaX;
  292.         if (newX > maxX)
  293.             newX = maxX;
  294.         if (newX < minX)
  295.             newX = minX;
  296.  
  297.         int newY = topRight.y + deltaY;
  298.         if (newY < minY)
  299.             newY = minY;
  300.         if (newY > maxY)
  301.             newY = maxY;
  302.  
  303.         topRight.set(newX, newY);
  304.     }
  305.  
  306.     private void adjustBottomLeft(int deltaX, int deltaY) {
  307.         int newX = bottomLeft.x + deltaX;
  308.         if (newX < minX)
  309.             newX = minX;
  310.         if (newX > maxX)
  311.             newX = maxX;
  312.  
  313.         int newY = bottomLeft.y + deltaY;
  314.         if (newY > maxY)
  315.             newY = maxY;
  316.         if (newY < minY)
  317.             newY = minY;
  318.  
  319.         bottomLeft.set(newX, newY);
  320.     }
  321.  
  322.     private void adjustBottomRight(int deltaX, int deltaY) {
  323.         int newX = bottomRight.x + deltaX;
  324.         if (newX > maxX)
  325.             newX = maxX;
  326.         if (newX < minX)
  327.             newX = minX;
  328.  
  329.         int newY = bottomRight.y + deltaY;
  330.         if (newY > maxY)
  331.             newY = maxY;
  332.         if (newY < minY)
  333.             newY = minY;
  334.  
  335.         bottomRight.set(newX, newY);
  336.     }
  337.  
  338.     public void crop(CropListener cropListener, boolean needStretch) {
  339.         if (topLeft == null)
  340.             return;
  341.  
  342.         // calculate bitmap size in new canvas
  343.         float scaleX = bitmap.getWidth() * 1.0f / getWidth();
  344.         float scaleY = bitmap.getHeight() * 1.0f / getHeight();
  345.         float maxScale = Math.max(scaleX, scaleY);
  346.  
  347.         // re-calculate coordinate in original bitmap
  348.         Log.e("stk", "maxScale=" + maxScale);
  349.  
  350.         Point bitmapTopLeft = new Point((int) ((topLeft.x - minX) * maxScale), (int) ((topLeft.y - minY) * maxScale));
  351.         Point bitmapTopRight = new Point((int) ((topRight.x - minX) * maxScale), (int) ((topRight.y - minY) * maxScale));
  352.         Point bitmapBottomLeft = new Point((int) ((bottomLeft.x - minX) * maxScale), (int) ((bottomLeft.y - minY) * maxScale));
  353.         Point bitmapBottomRight = new Point((int) ((bottomRight.x - minX) * maxScale), (int) ((bottomRight.y - minY) * maxScale));
  354.  
  355.         Log.e("stk", "bitmapPoints="
  356.                 + bitmapTopLeft.toString() + " "
  357.                 + bitmapTopRight.toString() + " "
  358.                 + bitmapBottomRight.toString() + " "
  359.                 + bitmapBottomLeft.toString() + " ");
  360.  
  361.         Bitmap output = Bitmap.createBitmap(bitmap.getWidth() + 1, bitmap.getHeight() + 1, Bitmap.Config.ARGB_8888);
  362.         Canvas canvas = new Canvas(output);
  363.  
  364.         Paint paint = new Paint();
  365.         // 1. draw path
  366.         Path path = new Path();
  367.         path.moveTo(bitmapTopLeft.x, bitmapTopLeft.y);
  368.         path.lineTo(bitmapTopRight.x, bitmapTopRight.y);
  369.         path.lineTo(bitmapBottomRight.x, bitmapBottomRight.y);
  370.         path.lineTo(bitmapBottomLeft.x, bitmapBottomLeft.y);
  371.         path.close();
  372.         canvas.drawPath(path, paint);
  373.  
  374.         // 2. draw original bitmap
  375.         paint.setXfermode(new PorterDuffXfermode(PorterDuff.Mode.SRC_IN));
  376.         canvas.drawBitmap(bitmap, 0, 0, paint);
  377.  
  378.         // 3. cut
  379.         Rect cropRect = new Rect(
  380.                 Math.min(bitmapTopLeft.x, bitmapBottomLeft.x),
  381.                 Math.min(bitmapTopLeft.y, bitmapTopRight.y),
  382.                 Math.max(bitmapBottomRight.x, bitmapTopRight.x),
  383.                 Math.max(bitmapBottomRight.y, bitmapBottomLeft.y));
  384.  
  385.         Bitmap cut = Bitmap.createBitmap(
  386.                 output,
  387.                 cropRect.left,
  388.                 cropRect.top,
  389.                 cropRect.width(),
  390.                 cropRect.height()
  391.         );
  392.  
  393.         if (!needStretch) {
  394.             cropListener.onFinish(cut);
  395.         } else {
  396.             // 4. re-calculate coordinate in cropRect
  397.             Point cutTopLeft = new Point();
  398.             Point cutTopRight = new Point();
  399.             Point cutBottomLeft = new Point();
  400.             Point cutBottomRight = new Point();
  401.  
  402.             cutTopLeft.x = bitmapTopLeft.x > bitmapBottomLeft.x ? bitmapTopLeft.x - bitmapBottomLeft.x : 0;
  403.             cutTopLeft.y = bitmapTopLeft.y > bitmapTopRight.y ? bitmapTopLeft.y - bitmapTopRight.y : 0;
  404.  
  405.             cutTopRight.x = bitmapTopRight.x > bitmapBottomRight.x ? cropRect.width() : cropRect.width() - Math.abs(bitmapBottomRight.x - bitmapTopRight.x);
  406.             cutTopRight.y = bitmapTopLeft.y > bitmapTopRight.y ? 0 : Math.abs(bitmapTopLeft.y - bitmapTopRight.y);
  407.  
  408.             cutBottomLeft.x = bitmapTopLeft.x > bitmapBottomLeft.x ? 0 : Math.abs(bitmapTopLeft.x - bitmapBottomLeft.x);
  409.             cutBottomLeft.y = bitmapBottomLeft.y > bitmapBottomRight.y ? cropRect.height() : cropRect.height() - Math.abs(bitmapBottomRight.y - bitmapBottomLeft.y);
  410.  
  411.             cutBottomRight.x = bitmapTopRight.x > bitmapBottomRight.x ? cropRect.width() - Math.abs(bitmapBottomRight.x - bitmapTopRight.x) : cropRect.width();
  412.             cutBottomRight.y = bitmapBottomLeft.y > bitmapBottomRight.y ? cropRect.height() - Math.abs(bitmapBottomRight.y - bitmapBottomLeft.y) : cropRect.height();
  413.  
  414.             Log.e("stk", cut.getWidth() + "x" + cut.getHeight());
  415.  
  416.             Log.e("stk", "cutPoints="
  417.                     + cutTopLeft.toString() + " "
  418.                     + cutTopRight.toString() + " "
  419.                     + cutBottomRight.toString() + " "
  420.                     + cutBottomLeft.toString() + " ");
  421.  
  422.             float width = cut.getWidth();
  423.             float height = cut.getHeight();
  424.  
  425.             float[] src = new float[]{cutTopLeft.x, cutTopLeft.y, cutTopRight.x, cutTopRight.y, cutBottomRight.x, cutBottomRight.y, cutBottomLeft.x, cutBottomLeft.y};
  426.             float[] dst = new float[]{0, 0, width, 0, width, height, 0, height};
  427.  
  428.             Matrix matrix = new Matrix();
  429.             matrix.setPolyToPoly(src, 0, dst, 0, 4);
  430.             Bitmap stretch = Bitmap.createBitmap(cut.getWidth(), cut.getHeight(), Bitmap.Config.ARGB_8888);
  431.  
  432.             Canvas stretchCanvas = new Canvas(stretch);
  433.             //            stretchCanvas.drawBitmap(cut, matrix, null);
  434.             stretchCanvas.concat(matrix);
  435.             stretchCanvas.drawBitmapMesh(cut, WIDTH_BLOCK, HEIGHT_BLOCK, generateVertices(cut.getWidth(), cut.getHeight()), 0, null, 0, null);
  436.  
  437.             cropListener.onFinish(stretch);
  438.         }
  439.     }
  440.  
  441.     private int WIDTH_BLOCK  = 40;
  442.     private int HEIGHT_BLOCK = 40;
  443.  
  444.     private float[] generateVertices(int widthBitmap, int heightBitmap) {
  445.  
  446.         float[] vertices = new float[(WIDTH_BLOCK + 1) * (HEIGHT_BLOCK + 1) * 2];
  447.  
  448.         float widthBlock = (float) widthBitmap / WIDTH_BLOCK;
  449.         float heightBlock = (float) heightBitmap / HEIGHT_BLOCK;
  450.  
  451.         for (int i = 0; i <= HEIGHT_BLOCK; i++)
  452.             for (int j = 0; j <= WIDTH_BLOCK; j++) {
  453.                 vertices[i * ((HEIGHT_BLOCK + 1) * 2) + (j * 2)] = j * widthBlock;
  454.                 vertices[i * ((HEIGHT_BLOCK + 1) * 2) + (j * 2) + 1] = i * heightBlock;
  455.             }
  456.         return vertices;
  457.     }
  458. }

github地址：WildmaIDCardCamera

参考资料：

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/weixin_40725706/article/detail/683033
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号