扫描头 补光灯和camera 流的关系

扫描头、补光灯和相机是数字化文档处理中的三个主要部分。扫描头用于捕捉图像，补光灯用于提供均匀的光照，相机用于转换光学信号为数字信号。

在数字化文档处理过程中，扫描头扫描文档并转换成数字信号。为了获得高质量的图像，需要提供均匀的光照。这就是补光灯的作用。补光灯会提供均匀的光照，以确保扫描头捕捉到整个图像的细节和颜色。最后，相机将光学信号转换成数字信号，并将其保存到计算机中。

因此，扫描头、补光灯和相机是数字化文档处理中密切相关的三个部分，它们一起协作实现数字化文档的处理。

相关问题

使用camera2扫描二维码并且扫描结束后打开闪光灯的代码

以下是使用camera2扫描二维码并且扫描结束后打开闪光灯的代码：

private CameraManager mCameraManager;
private String mCameraId;
private CameraDevice mCameraDevice;
private CameraCaptureSession mCaptureSession;
private CaptureRequest.Builder mPreviewRequestBuilder;
private TextureView mTextureView;
private HandlerThread mBackgroundThread;
private Handler mBackgroundHandler;
private ImageReader mImageReader;
private boolean mFlashSupported;
private boolean mFlashState;

private final CameraDevice.StateCallback mCameraCallback = new CameraDevice.StateCallback() {
    @Override
    public void onOpened(@NonNull CameraDevice cameraDevice) {
        mCameraDevice = cameraDevice;
        createCameraPreviewSession();
    }

    @Override
    public void onDisconnected(@NonNull CameraDevice cameraDevice) {
        cameraDevice.close();
        mCameraDevice = null;
    }

    @Override
    public void onError(@NonNull CameraDevice cameraDevice, int error) {
        cameraDevice.close();
        mCameraDevice = null;
    }
};

private final CameraCaptureSession.StateCallback mSessionCallback = new CameraCaptureSession.StateCallback() {
    @Override
    public void onConfigured(@NonNull CameraCaptureSession cameraCaptureSession) {
        if (mCameraDevice == null) {
            return;
        }
        mCaptureSession = cameraCaptureSession;
        try {
            mPreviewRequestBuilder.set(CaptureRequest.CONTROL_AF_MODE, CaptureRequest.CONTROL_AF_MODE_CONTINUOUS_PICTURE);
            setAutoFlash(mPreviewRequestBuilder);
            mCaptureSession.setRepeatingRequest(mPreviewRequestBuilder.build(), null, mBackgroundHandler);
        } catch (CameraAccessException e) {
            e.printStackTrace();
        }
    }

    @Override
    public void onConfigureFailed(@NonNull CameraCaptureSession cameraCaptureSession) {
        Toast.makeText(getApplicationContext(), "Failed", Toast.LENGTH_SHORT).show();
    }
};

private final ImageReader.OnImageAvailableListener mOnImageAvailableListener = new ImageReader.OnImageAvailableListener() {
    @Override
    public void onImageAvailable(ImageReader reader) {
        mBackgroundHandler.post(new ImageSaver(reader.acquireLatestImage()));
    }
};

private static class ImageSaver implements Runnable {
    private final Image mImage;

    ImageSaver(Image image) {
        mImage = image;
    }

    @Override
    public void run() {
        // 解析二维码

        mImage.close();
    }
}

@Override
protected void onResume() {
    super.onResume();
    startBackgroundThread();
    if (mTextureView.isAvailable()) {
        openCamera(mTextureView.getWidth(), mTextureView.getHeight());
    } else {
        mTextureView.setSurfaceTextureListener(mSurfaceTextureListener);
    }
}

@Override
protected void onPause() {
    closeCamera();
    stopBackgroundThread();
    super.onPause();
}

private void startBackgroundThread() {
    mBackgroundThread = new HandlerThread("CameraBackground");
    mBackgroundThread.start();
    mBackgroundHandler = new Handler(mBackgroundThread.getLooper());
}

private void stopBackgroundThread() {
    mBackgroundThread.quitSafely();
    try {
        mBackgroundThread.join();
        mBackgroundThread = null;
        mBackgroundHandler = null;
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
}

private void openCamera(int width, int height) {
    setUpCameraOutputs(width, height);
    configureTransform(width, height);
    mCameraManager = (CameraManager) getSystemService(Context.CAMERA_SERVICE);
    try {
        if (ActivityCompat.checkSelfPermission(this, Manifest.permission.CAMERA) != PackageManager.PERMISSION_GRANTED) {
            return;
        }
        mCameraManager.openCamera(mCameraId, mCameraCallback, null);
    } catch (CameraAccessException e) {
        e.printStackTrace();
    }
}

private void closeCamera() {
    try {
        mCaptureSession.stopRepeating();
        mCaptureSession.abortCaptures();
    } catch (CameraAccessException e) {
        e.printStackTrace();
    }
    mCaptureSession.close();
    mCaptureSession = null;
    mCameraDevice.close();
    mCameraDevice = null;
    mImageReader.close();
    mImageReader = null;
}

private void createCameraPreviewSession() {
    try {
        SurfaceTexture texture = mTextureView.getSurfaceTexture();
        texture.setDefaultBufferSize(mPreviewSize.getWidth(), mPreviewSize.getHeight());
        Surface surface = new Surface(texture);
        mPreviewRequestBuilder = mCameraDevice.createCaptureRequest(CameraDevice.TEMPLATE_PREVIEW);
        mPreviewRequestBuilder.addTarget(surface);
        mImageReader = ImageReader.newInstance(mPreviewSize.getWidth(), mPreviewSize.getHeight(), ImageFormat.YUV_420_888, 2);
        mImageReader.setOnImageAvailableListener(mOnImageAvailableListener, mBackgroundHandler);
        mPreviewRequestBuilder.addTarget(mImageReader.getSurface());
        mCameraDevice.createCaptureSession(Arrays.asList(surface, mImageReader.getSurface()), mSessionCallback, mBackgroundHandler);
    } catch (CameraAccessException e) {
        e.printStackTrace();
    }
}

private void setUpCameraOutputs(int width, int height) {
    mCameraManager = (CameraManager) getSystemService(Context.CAMERA_SERVICE);
    try {
        for (String cameraId : mCameraManager.getCameraIdList()) {
            CameraCharacteristics characteristics = mCameraManager.getCameraCharacteristics(cameraId);
            Integer facing = characteristics.get(CameraCharacteristics.LENS_FACING);
            if (facing != null && facing == CameraCharacteristics.LENS_FACING_BACK) {
                StreamConfigurationMap map = characteristics.get(CameraCharacteristics.SCALER_STREAM_CONFIGURATION_MAP);
                if (map == null) {
                    continue;
                }
                Size largest = Collections.max(Arrays.asList(map.getOutputSizes(ImageFormat.YUV_420_888)), new CompareSizesByArea());
                mImageReader = ImageReader.newInstance(largest.getWidth(), largest.getHeight(), ImageFormat.YUV_420_888, 2);
                mPreviewSize = chooseOptimalSize(map.getOutputSizes(SurfaceTexture.class), width, height, largest);
                mCameraId = cameraId;
                break;
            }
        }
    } catch (CameraAccessException e) {
        e.printStackTrace();
    }
}

private void configureTransform(int viewWidth, int viewHeight) {
    if (null == mTextureView || null == mPreviewSize) {
        return;
    }
    int rotation = getWindowManager().getDefaultDisplay().getRotation();
    Matrix matrix = new Matrix();
    RectF viewRect = new RectF(0, 0, viewWidth, viewHeight);
    RectF bufferRect = new RectF(0, 0, mPreviewSize.getHeight(), mPreviewSize.getWidth());
    float centerX = viewRect.centerX();
    float centerY = viewRect.centerY();
    if (Surface.ROTATION_90 == rotation || Surface.ROTATION_270 == rotation) {
        bufferRect.offset(centerX - bufferRect.centerX(), centerY - bufferRect.centerY());
        matrix.setRectToRect(viewRect, bufferRect, Matrix.ScaleToFit.FILL);
        float scale = Math.max((float) viewHeight / mPreviewSize.getHeight(), (float) viewWidth / mPreviewSize.getWidth());
        matrix.postScale(scale, scale, centerX, centerY);
        matrix.postRotate(90 * (rotation - 2), centerX, centerY);
    }
    mTextureView.setTransform(matrix);
}

private static Size chooseOptimalSize(Size[] choices, int width, int height, Size aspectRatio) {
    List<Size> bigEnough = new ArrayList<>();
    for (Size option : choices) {
        if (option.getHeight() == option.getWidth() * aspectRatio.getHeight() / aspectRatio.getWidth() && option.getWidth() >= width && option.getHeight() >= height) {
            bigEnough.add(option);
        }
    }
    if (bigEnough.size() > 0) {
        return Collections.min(bigEnough, new CompareSizesByArea());
    } else {
        return choices[0];
    }
}

private static class CompareSizesByArea implements Comparator<Size> {
    @Override
    public int compare(Size lhs, Size rhs) {
        return Long.signum((long) lhs.getWidth() * lhs.getHeight() - (long) rhs.getWidth() * rhs.getHeight());
    }
}

private final TextureView.SurfaceTextureListener mSurfaceTextureListener = new TextureView.SurfaceTextureListener() {
    @Override
    public void onSurfaceTextureAvailable(SurfaceTexture surfaceTexture, int width, int height) {
        openCamera(width, height);
    }

    @Override
    public void onSurfaceTextureSizeChanged(SurfaceTexture surfaceTexture, int width, int height) {
        configureTransform(width, height);
    }

    @Override
    public boolean onSurfaceTextureDestroyed(SurfaceTexture surfaceTexture) {
        return true;
    }

    @Override
    public void onSurfaceTextureUpdated(SurfaceTexture surfaceTexture) {
    }
};

private void setAutoFlash(CaptureRequest.Builder requestBuilder) {
    if (mFlashSupported) {
        if (mFlashState) {
            requestBuilder.set(CaptureRequest.CONTROL_AE_MODE, CaptureRequest.CONTROL_AE_MODE_ON_AUTO_FLASH);
        } else {
            requestBuilder.set(CaptureRequest.CONTROL_AE_MODE, CaptureRequest.CONTROL_AE_MODE_ON);
        }
    }
}

private void setFlashState(boolean state) {
    mFlashState = state;
    if (mCaptureSession != null) {
        try {
            mPreviewRequestBuilder.set(CaptureRequest.CONTROL_AE_MODE, mFlashState ? CaptureRequest.CONTROL_AE_MODE_ON_AUTO_FLASH : CaptureRequest.CONTROL_AE_MODE_ON);
            mCaptureSession.setRepeatingRequest(mPreviewRequestBuilder.build(), null, mBackgroundHandler);
        } catch (CameraAccessException e) {
            e.printStackTrace();
        }
    }
}

在 `createCameraPreviewSession()` 方法中可以看到，我们添加了一个 `ImageReader` 用于获取相机捕获的数据，我们可以在 `mOnImageAvailableListener` 监听器中对数据进行解析，这里我们可以使用 `Zxing` 库进行解析二维码：

private static class ImageSaver implements Runnable {
    private final Image mImage;

    ImageSaver(Image image) {
        mImage = image;
    }

    @Override
    public void run() {
        ByteBuffer buffer = mImage.getPlanes()[0].getBuffer();
        byte[] data = new byte[buffer.remaining()];
        buffer.get(data);
        PlanarYUVLuminanceSource source = new PlanarYUVLuminanceSource(data, mImage.getWidth(), mImage.getHeight(), 0, 0, mImage.getWidth(), mImage.getHeight(), false);
        BinaryBitmap bitmap = new BinaryBitmap(new HybridBinarizer(source));
        MultiFormatReader reader = new MultiFormatReader();
        try {
            Result result = reader.decode(bitmap);
            Log.d(TAG, "result: " + result.getText());
        } catch (NotFoundException e) {
            e.printStackTrace();
        } finally {
            mImage.close();
        }
    }
}

至于如何打开闪光灯，我们可以在 `setAutoFlash()` 方法中设置 `CaptureRequest.CONTROL_AE_MODE` 参数为 `CaptureRequest.CONTROL_AE_MODE_ON_AUTO_FLASH` 或 `CaptureRequest.CONTROL_AE_MODE_ON` 来控制闪光灯的开关状态。同时，在 `setFlashState()` 方法中可以动态地切换闪光灯状态。

联想小新一体机扫描头原理

联想小新一体机扫描头是通过光学原理来实现扫描图像的。它通过一个移动的光源和一个静止的接收器来捕捉图像。光源照射到物体上，反射回来的光线被接收器捕捉，然后通过电子元件转换成数字信号，最终被计算机识别为图像。