Android 使用camera2 api捕获图像

我在一个应用程序中工作，我需要在横向模式下捕获图像。该功能运行良好，但我遇到的问题是，每当捕获图像时，我都会得到捕获图像的额外一面。我在使用transform方法时遇到了这个问题（代码如下）。请告诉我如何删除图像的多余部分。请看下面的图片

1） 在拍摄图像之前

2） 拍摄图像后

摄像机横向模式代码

private void transformImage(int viewWidth, int viewHeight) {
    if (null == textureView || null == previewSize) {
        return;
    }
    int rotation = getWindowManager().getDefaultDisplay().getRotation();
    matrix = new Matrix();
    RectF viewRect = new RectF(0, 0, viewWidth, viewHeight);
    RectF bufferRect = new RectF(0, 0, previewSize.getHeight(), previewSize.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 / previewSize.getHeight(),
                (float) viewWidth / previewSize.getWidth());
        matrix.postScale(scale, scale, centerX, centerY);
        matrix.postRotate(90 * (rotation - 2), centerX, centerY);
    } else if (Surface.ROTATION_180 == rotation) {
        matrix.postRotate(180, centerX, centerY);
    }
    textureView.setTransform(matrix);
}

用于捕获图像的代码

void getPicture() {
    if (cameraDevice == null) {
        return;
    }
    CameraManager manager = (CameraManager) getSystemService(Context.CAMERA_SERVICE);
    try {
        assert manager != null;
        CameraCharacteristics characteristics = manager.getCameraCharacteristics(cameraDevice.getId());
        if (characteristics != null) {
     jpegSizes = characteristics.get(CameraCharacteristics.SCALER_STREAM_CONFIGURATION_MAP).getOutputSizes(ImageFormat.JPEG);
        }
        int width = 640, height = 480;
        if (jpegSizes != null && jpegSizes.length > 0) {

            width = jpegSizes[0].getWidth();
            height = jpegSizes[0].getHeight();

        }
        final ImageReader reader = ImageReader.newInstance(width, height, ImageFormat.JPEG, 1);
        List<Surface> outputSurfaces = new ArrayList<Surface>(2);
        outputSurfaces.add(reader.getSurface());

        outputSurfaces.add(new Surface(textureView.getSurfaceTexture()));
        final CaptureRequest.Builder capturebuilder = cameraDevice.createCaptureRequest(CameraDevice.TEMPLATE_STILL_CAPTURE);
        capturebuilder.addTarget(reader.getSurface());
        capturebuilder.set(CaptureRequest.CONTROL_MODE, CameraMetadata.CONTROL_MODE_AUTO);
        int rotation = getWindowManager().getDefaultDisplay().getRotation();
        capturebuilder.set(CaptureRequest.JPEG_ORIENTATION, ORIENTATION.get(rotation));



        ImageReader.OnImageAvailableListener imageAvailableListener = new ImageReader.OnImageAvailableListener() {
            @Override
            public void onImageAvailable(ImageReader reader) {
                Image image = null;
                try {
                    image = reader.acquireLatestImage();
                    ByteBuffer buffer = image.getPlanes()[0].getBuffer();
                    bytes = new byte[buffer.capacity()];
                    buffer.get(bytes);
                    save(bytes);
                } catch (Exception ee) {
                    Log.e("ImageReader Error ", ee.getMessage());
                } finally {
                    if (image != null)
                        image.close();
                }
            }

            void save(byte[] bytes) {

                File file12 = getOutputMediaFile();
                OutputStream outputStream = null;
                try {
                    assert file12 != null;
                    //file12 = new Compressor(VehicleEpaCamera.this).compressToFile(file12);
                    outputStream = new FileOutputStream(file12);
                    outputStream.write(bytes);
                } catch (Exception e) {
                    e.printStackTrace();
                } finally {
                    try {
                        if (outputStream != null)
                            outputStream.close();
                    } catch (Exception e) {
                    }
                }
            }
        };

        reader.setOnImageAvailableListener(imageAvailableListener, handler);
        previewSSession = new CameraCaptureSession.CaptureCallback() {
            @Override
            public void onCaptureStarted(CameraCaptureSession session, CaptureRequest request, long timestamp, long frameNumber) {
                super.onCaptureStarted(session, request, timestamp, frameNumber);
            }

            @Override
            public void onCaptureCompleted(CameraCaptureSession session, CaptureRequest request, TotalCaptureResult result) {
                super.onCaptureCompleted(session, request, result);

                try {
                    session.stopRepeating();
                } catch (CameraAccessException e) {
                    Toast.makeText(VehicleEpaCamera.this, e.getMessage(), Toast.LENGTH_SHORT).show();
                    e.printStackTrace();
                }
                if (bytes != null) {

                    callCloudVision(bitmap, feature);

                } else {
                    Toast.makeText(VehicleEpaCamera.this, "Something went wrong", Toast.LENGTH_SHORT).show();
                    getPicture();
                }
            }
        };
        cameraDevice.createCaptureSession(outputSurfaces, new CameraCaptureSession.StateCallback() {
            @Override
            public void onConfigured(CameraCaptureSession session) {
                try {
                    session.capture(capturebuilder.build(), previewSSession, handler);
                } catch (Exception e) {
                }
            }

            @Override
            public void onConfigureFailed(CameraCaptureSession session) {
            }
        }, handler);
    } catch (Exception e) {
    }
}

void getPicture（）{
如果（cameraDevice==null）{
返回；
}
CameraManager=（CameraManager）getSystemService（Context.CAMERA_服务）；
试一试{
断言管理器！=null；
CameraCharacteristics characteristics=manager.getCameraCharacteristics（cameraDevice.getId（））；
如果（特征！=null）{
jpegSizes=characteristics.get（CameraCharacteristics.SCALER\u STREAM\u CONFIGURATION\u MAP）.getOutputSizes（ImageFormat.JPEG）；
}
内部宽度=640，高度=480；
如果（jpegSizes！=null&&jpegSizes.length>0）{
宽度=JPEG大小[0]。getWidth（）；
高度=JPEG大小[0]。getHeight（）；
}
最终ImageReader=ImageReader.newInstance（宽度、高度、ImageFormat.JPEG，1）；
List outputSurfaces=新的ArrayList（2）；
add（reader.getSurface（））；
添加（新曲面（textureView.getSurfaceTexture（））；
final CaptureRequest.Builder capturebuilder=cameraDevice.createCaptureRequest（cameraDevice.TEMPLATE\u STILL\u CAPTURE）；
addTarget（reader.getSurface（））；
capturebuilder.set（CaptureRequest.CONTROL_模式，CameraMetadata.CONTROL_模式自动）；
int rotation=getWindowManager（）.getDefaultDisplay（）.getRotation（）；
set（CaptureRequest.JPEG_-ORIENTATION，ORIENTATION.get（rotation））；
ImageReader.OnImageAvailableListener imageAvailableListener=新建ImageReader.OnImageAvailableListener（）{
@凌驾
公共图像可用（图像阅读器）{
图像=空；
试一试{
image=reader.acquiredlatestimage（）；
ByteBuffer buffer=image.getPlanes（）[0].getBuffer（）；
字节=新字节[buffer.capacity（）]；
buffer.get（字节）；
保存（字节）；
}捕获（异常ee）{
Log.e（“ImageReader错误”，ee.getMessage（））；
}最后{
如果（图像！=null）
image.close（）；
}
}
无效保存（字节[]字节）{
File file12=getOutputMediaFile（）；
OutputStream OutputStream=null；
试一试{
断言文件12！=null；
//file12=新压缩机（VehicleEpaCamera.this）.compressToFile（file12）；
outputStream=新文件outputStream（文件12）；
outputStream.write（字节）；
}捕获（例外e）{
e、 printStackTrace（）；
}最后{
试一试{
if（outputStream！=null）
outputStream.close（）；
}捕获（例外e）{
}
}
}
};
reader.setOnImageAvailableListener（imageAvailableListener，handler）；
PreviewSession=新建CameraCaptureSession.CaptureCallback（）{
@凌驾
public void onCaptureStarted（CameraCaptureSession会话、CaptureRequest请求、长时间戳、长帧号）{
super.onCaptureStarted（会话、请求、时间戳、帧号）；
}
@凌驾
捕获完成后的公共void（CameraCaptureSession会话、CaptureRequest请求、TotalCaptureResult）{
super.onCaptureCompleted（会话、请求、结果）；
试一试{
session.stopRepeating（）；
}捕获（CameraAccessE异常）{
Toast.makeText（VehicleEpaCamera.this，e.getMessage（），Toast.LENGTH_SHORT.show（）；
e、 printStackTrace（）；
}
如果（字节数！=null）{
callCloudVision（位图、功能）；
}否则{
Toast.makeText（VehicleEpaCamera.this，“出了问题”，Toast.LENGTH_SHORT.show（）；
getPicture（）；
}
}
};
cameraDevice.createCaptureSession（outputSurfaces，新的CameraCaptureSession.StateCallback（）{
@凌驾
未配置公共void（CameraCaptureSession会话）{
试一试{
capture（capturebuilder.build（），previewSSession，handler）；
}捕获（例外e）{
}
}
@凌驾
配置文件的公共无效（CameraCaptureSession）{
}
}，处理程序）；
}捕获（例外e）{
}
}

您确定这两个图像不是不同的吗？我觉得很难理解。是的，两者都是相同的图像如果我删除transformImage方法，那么我将得到屏幕上的实际图像，问题是相机将在纵向模式下工作我已更新图像您是否担心预览图像和捕获图像的纵横比不同？