Camera2 api 获取摄像头预览画面并设置取景框

已于 2024-07-29 17:49:43 修改
阅读量140 收藏
点赞数 3
文章标签： 前端 javascript 开发语言 android-studio
于 2024-07-29 17:42:08 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_78330059/article/details/140776790
版权

说明：权限等代码已经包含在页面中，注意别忘了申请权限

预览效果-->apk文件在资源绑定中

一、下载依赖

/*项目主要依赖*/
    //camera2
    implementation 'androidx.camera:camera-camera2:1.2.0'
    implementation 'androidx.camera:camera-lifecycle:1.2.0'
    //ML-kit文字识别
    implementation 'com.google.mlkit:text-recognition:16.0.0'

二、页面布局

<?xml version="1.0" encoding="utf-8"?>
<androidx.constraintlayout.widget.ConstraintLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:id="@+id/main"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    tools:context=".MainActivity">

    <TextureView
        android:id="@+id/texture_view"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        app:layout_constraintBottom_toBottomOf="parent"
        app:layout_constraintEnd_toEndOf="parent"
        app:layout_constraintStart_toStartOf="parent"
        app:layout_constraintTop_toTopOf="parent" />


    <FrameLayout
        android:id="@+id/frame_layout"
        android:layout_width="280dp"
        android:layout_height="80dp"
        android:background="@drawable/rectangle_frame"
        app:layout_constraintBottom_toBottomOf="parent"
        app:layout_constraintEnd_toEndOf="parent"
        app:layout_constraintHorizontal_bias="0.497"
        app:layout_constraintStart_toStartOf="parent"
        app:layout_constraintTop_toTopOf="parent"
        app:layout_constraintVertical_bias="0.213"></FrameLayout>

    <ImageView
        android:id="@+id/captured_image"
        android:layout_width="280dp"
        android:layout_height="80dp"
        android:elevation="10dp"
        android:scaleType="fitXY"
        android:src="@drawable/four"
        app:layout_constraintBottom_toBottomOf="parent"
        app:layout_constraintEnd_toEndOf="parent"
        app:layout_constraintHorizontal_bias="0.496"
        app:layout_constraintStart_toStartOf="parent"
        app:layout_constraintTop_toTopOf="parent"
        android:visibility="gone"
        app:layout_constraintVertical_bias="0.499" />

    <TextView
        android:id="@+id/tv_result"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:gravity="center"
        android:text="TTT666666"
        android:textColor="@color/colorRed"
        android:textSize="30sp"
        android:textStyle="bold"
        app:layout_constraintBottom_toBottomOf="parent"
        app:layout_constraintEnd_toEndOf="parent"
        app:layout_constraintHorizontal_bias="0.498"
        app:layout_constraintStart_toStartOf="parent"
        app:layout_constraintTop_toTopOf="parent"
        app:layout_constraintVertical_bias="0.665" />

    <Button
        android:id="@+id/start_stop_button"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="开始识别"
        android:onClick="restartIdentify"
        app:layout_constraintBottom_toBottomOf="parent"
        app:layout_constraintEnd_toEndOf="parent"
        app:layout_constraintStart_toStartOf="parent"/>

</androidx.constraintlayout.widget.ConstraintLayout>

三、页面代码

package com.example.tirenumberrecognition;

import android.Manifest;
import android.annotation.SuppressLint;
import android.content.DialogInterface;
import android.content.pm.PackageManager;
import android.graphics.Bitmap;
import android.graphics.Canvas;
import android.graphics.Matrix;
import android.graphics.Paint;
import android.graphics.RectF;
import android.graphics.SurfaceTexture;
import android.hardware.camera2.CameraAccessException;
import android.hardware.camera2.CameraCaptureSession;
import android.hardware.camera2.CameraCharacteristics;
import android.hardware.camera2.CameraDevice;
import android.hardware.camera2.CameraManager;
import android.hardware.camera2.CaptureRequest;
import android.hardware.camera2.params.StreamConfigurationMap;
import android.media.Image;
import android.media.ImageReader;
import android.os.Build;
import android.os.Bundle;
import android.os.Handler;
import android.os.HandlerThread;
import android.util.Log;
import android.util.Size;
import android.view.Surface;
import android.view.TextureView;
import android.view.View;
import android.widget.FrameLayout;
import android.widget.ImageView;
import android.widget.TextView;
import android.widget.Toast;

import androidx.activity.EdgeToEdge;
import androidx.annotation.NonNull;
import androidx.appcompat.app.AlertDialog;
import androidx.appcompat.app.AppCompatActivity;
import androidx.core.app.ActivityCompat;
import androidx.core.graphics.Insets;
import androidx.core.view.ViewCompat;
import androidx.core.view.WindowInsetsCompat;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
import android.os.Looper;
import android.widget.VideoView;

import com.google.android.gms.tasks.OnFailureListener;
import com.google.android.gms.tasks.OnSuccessListener;
import com.google.mlkit.vision.common.InputImage;
import com.google.mlkit.vision.text.Text;
import com.google.mlkit.vision.text.TextRecognition;
import com.google.mlkit.vision.text.TextRecognizer;
import com.google.mlkit.vision.text.latin.TextRecognizerOptions;

public class MainActivity extends AppCompatActivity {
    private final static int PERMISSION_REQUEST_CODE = 666666;//权限请求code--请求标识
    /*权限请求字符集*/
    private String[] permissions = {
            android.Manifest.permission.WRITE_EXTERNAL_STORAGE,
            android.Manifest.permission.READ_EXTERNAL_STORAGE,
            Manifest.permission.CAMERA
    };
    private TextureView textureView;
    private FrameLayout frameLayout;
    private ImageView mImageView;
    private TextView mTextView;
    private Handler handler = new Handler(Looper.getMainLooper());
    private Runnable captureRunnable = new Runnable() {
        @Override
        public void run() {
            if(identifyFlag) {
                captureBitmapFromTextureView();
            }
            handler.postDelayed(this, 1500); // 每隔1秒重新执行
        }
    };

    private CameraDevice cameraDevice;
    private CameraCaptureSession cameraCaptureSessions;
    private CaptureRequest.Builder captureRequestBuilder;
    private Size imageDimension;
    private Size previewSize; // 新增的尺寸变量
    private ImageReader imageReader;
    private static final String CAMERA_ID = "0";
    private Handler mBackgroundHandler;
    private HandlerThread mBackgroundThread;

    @SuppressLint("MissingInflatedId")
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        EdgeToEdge.enable(this);
        setContentView(R.layout.activity_main);
        ViewCompat.setOnApplyWindowInsetsListener(findViewById(R.id.main), (v, insets) -> {
            Insets systemBars = insets.getInsets(WindowInsetsCompat.Type.systemBars());
            v.setPadding(systemBars.left, systemBars.top, systemBars.right, systemBars.bottom);
            return insets;
        });

        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M
                && checkSelfPermission(permissions[0]) != PackageManager.PERMISSION_GRANTED
                && checkSelfPermission(permissions[1]) != PackageManager.PERMISSION_GRANTED
                && checkSelfPermission(permissions[2]) != PackageManager.PERMISSION_GRANTED)
        {
            requestPermissions(permissions, PERMISSION_REQUEST_CODE);
        }

        textureView = findViewById(R.id.texture_view);
        textureView.setSurfaceTextureListener(textureListener);
        mImageView = findViewById(R.id.captured_image);
        mTextView = findViewById(R.id.tv_result);
        frameLayout = findViewById(R.id.frame_layout);
    }

    //监听textureView的生命周期
    private final TextureView.SurfaceTextureListener textureListener = new TextureView.SurfaceTextureListener() {
        @Override
        public void onSurfaceTextureAvailable(@NonNull SurfaceTexture surface, int width, int height) {
            openCamera();

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

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

        @Override
        public void onSurfaceTextureUpdated(@NonNull SurfaceTexture surface) {
//            captureBitmapFromTextureView();
        }
    };
    private boolean identifyFlag = false;
    public void restartIdentify(View view) {
        handler.removeCallbacks(captureRunnable);
        handler.postDelayed(captureRunnable, 1500);
        identifyFlag = true;
    }
    private void captureBitmapFromTextureView() {
        // 获取取景框的位置
        Bitmap bitmap = textureView.getBitmap();
        int frameWidth = frameLayout.getWidth();
        int frameHeight = frameLayout.getHeight();
        float frameX = frameLayout.getX();
        float frameY = frameLayout.getY();

        frameX += 0; // 根据实际情况调整值
        frameY -= 20;
        // 裁剪Bitmap
        Bitmap croppedBitmap = Bitmap.createBitmap(
                bitmap,
                (int) frameX,
                (int) frameY,
                frameWidth,
                frameHeight
        );
        recognizeTextFromBitmap(croppedBitmap);

        // 显示Bitmap到ImageView
/*        runOnUiThread(new Runnable() {
            @Override
            public void run() {
                mImageView.setImageBitmap(croppedBitmap);
            }
        });*/

    }
    private void recognizeTextFromBitmap(Bitmap bitmap) {
        InputImage image = InputImage.fromBitmap(bitmap, 0);
        TextRecognizer myRecognizer = TextRecognition.getClient(TextRecognizerOptions.DEFAULT_OPTIONS);
        myRecognizer.process(image).addOnSuccessListener(new OnSuccessListener<Text>() {
            @Override
            public void onSuccess(com.google.mlkit.vision.text.Text text) {
                String text1 = text.getText();
                if(text1.length() > 7 && text1.length() < 14) {
                    identifyFlag = false;
                    handler.removeCallbacks(captureRunnable);
                    mTextView.setText(text1);
                    myRecognizer.close();
                    ShowDialog(text1);
                }
            }
        }).addOnFailureListener(new OnFailureListener() {
            @Override
            public void onFailure(@NonNull Exception e) {
                // 处理错误
                e.printStackTrace();
                // 释放资源
                myRecognizer.close();
            }
        });
    }
    private void ShowDialog(String s) {
        AlertDialog alertDialog2 = new AlertDialog.Builder(this)
                .setTitle("识别结果")
                .setMessage(s)
                .setIcon(R.mipmap.ic_launcher)
                .setPositiveButton("确定", new DialogInterface.OnClickListener() {//添加"Yes"按钮
                    @Override
                    public void onClick(DialogInterface dialogInterface, int i) {
                        handler.removeCallbacks(captureRunnable);
                        dialogInterface.dismiss();
                    }
                })

                .setNegativeButton("重新识别", new DialogInterface.OnClickListener() {//添加取消
                    @Override
                    public void onClick(DialogInterface dialogInterface, int i) {
                        dialogInterface.dismiss();
                        handler.removeCallbacks(captureRunnable);
                        handler.postDelayed(captureRunnable, 1500);
                        identifyFlag = true;
                    }
                })
                .create();
        alertDialog2.show();
    }
    private CameraManager manager;
    private void openCamera() {
        manager = (CameraManager) getSystemService(CAMERA_SERVICE);
        try {
            CameraCharacteristics characteristics = manager.getCameraCharacteristics(CAMERA_ID);
            StreamConfigurationMap map = characteristics.get(CameraCharacteristics.SCALER_STREAM_CONFIGURATION_MAP);
            if (map != null) {
                // 选择预览尺寸
                previewSize = chooseOptimalSize(map.getOutputSizes(SurfaceTexture.class), textureView.getWidth(), textureView.getHeight());

                // Add permission for camera and let user grant the permission
                if (ActivityCompat.checkSelfPermission(this, android.Manifest.permission.CAMERA) != PackageManager.PERMISSION_GRANTED) {
                    ActivityCompat.requestPermissions(MainActivity.this, new String[]{Manifest.permission.CAMERA}, 100);
                    return;
                }
                manager.openCamera(CAMERA_ID, stateCallback, null);
            } else {
                Log.e("CameraActivity", "StreamConfigurationMap is null");
            }
        } catch (CameraAccessException e) {
            e.printStackTrace();
        }
    }

    //此方法根据TextureView的宽度和高度选择一个合适的预览尺寸，以确保预览画面填充整个视图
    @SuppressLint("RestrictedApi")
    private Size chooseOptimalSize(Size[] choices, int textureViewWidth, int textureViewHeight) {
        List<Size> bigEnough = new ArrayList<>();
        int w = textureViewWidth;
        int h = textureViewHeight;
        if (choices != null) {
            for (Size option : choices) {
                if (option.getHeight() == option.getWidth() * h / w && option.getWidth() >= w && option.getHeight() >= h) {
                    bigEnough.add(option);
                }
            }
        }

        if (!bigEnough.isEmpty()) {
            return Collections.min(bigEnough, new CompareSizesByArea());
        } else {
            // If no suitable size was found, return the first one or handle it as needed.
            return choices != null && choices.length > 0 ? choices[0] : null;
        }
    }
    //当摄像头设备的状态发生变化时，例如打开成功或失败，这个回调会被调用
    CameraDevice.StateCallback stateCallback = new CameraDevice.StateCallback() {
        @Override
        public void onOpened(@NonNull CameraDevice camera) {
            // This is called when the camera is opened
            cameraDevice = camera;
            createCameraPreview();
        }

        @Override
        public void onDisconnected(@NonNull CameraDevice camera) {
            cameraDevice.close();
        }

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

    //这是一个比较器，用于根据尺寸的面积大小进行排序，以帮助选择最佳尺寸
    private class CompareSizesByArea implements Comparator<Size> {
        @Override
        public int compare(Size lhs, Size rhs) {
            // We cast here to ensure the multiplications won't overflow
            return Long.signum((long) lhs.getWidth() * lhs.getHeight() -
                    (long) rhs.getWidth() * rhs.getHeight());
        }
    }

    //这个方法创建了一个CameraCaptureSession，并将预览画面配置为TextureView的输出
    private void createCameraPreview() {
        try {
            SurfaceTexture texture = textureView.getSurfaceTexture();
            if (texture != null && previewSize != null) {
                // We configure the size of default buffer to be the size of camera preview we want.
                texture.setDefaultBufferSize(previewSize.getWidth(), previewSize.getHeight());

                // This is the output Surface we need to start preview.
                Surface surface = new Surface(texture);

                // We set up a CaptureRequest.Builder with the output Surface.
                captureRequestBuilder = cameraDevice.createCaptureRequest(CameraDevice.TEMPLATE_PREVIEW);
                captureRequestBuilder.addTarget(surface);
                //设置自动对焦
                captureRequestBuilder.set(CaptureRequest.CONTROL_AF_MODE, CaptureRequest.CONTROL_AF_MODE_CONTINUOUS_PICTURE);
                //获取并设置ISO
                /*
                CameraCharacteristics characteristics = manager.getCameraCharacteristics(CAMERA_ID);
                // 获取最小和最大 ISO 值
                int minIso = characteristics.get(CameraCharacteristics.SENSOR_INFO_SENSITIVITY_RANGE).getLower();
                int maxIso = characteristics.get(CameraCharacteristics.SENSOR_INFO_SENSITIVITY_RANGE).getUpper();
                Log.i("TAG", "createCameraPreview-maxIso: " + maxIso);
                * */

                /*
                // 设置ISO
                captureRequestBuilder.set(CaptureRequest.SENSOR_SENSITIVITY, 1600);
                * */

                // Now that we have set our Surface textures, we can open the camera preview and start taking pictures.
                cameraDevice.createCaptureSession(Arrays.asList(surface), new CameraCaptureSession.StateCallback() {
                    @Override
                    public void onConfigured(@NonNull CameraCaptureSession session) {
                        // The camera is already closed
                        if (null == cameraDevice) {
                            return;
                        }

                        // When the session is ready, we start displaying the preview.
                        cameraCaptureSessions = session;
                        updatePreview();
                    }

                    @Override
                    public void onConfigureFailed(@NonNull CameraCaptureSession session) {
                        // Called when the camera could not be configured
                    }
                }, null);
            } else {
                Log.e("CameraActivity", "Texture or previewSize is null");
            }
        } catch (CameraAccessException e) {
            e.printStackTrace();
        }
    }
    //这个方法设置了一个重复的捕获请求，以保持预览画面的更新
    private void updatePreview() {
        if (null == cameraDevice) {
            Log.e("CameraActivity", "updatePreview error, return");
        }
//        captureRequestBuilder.set(CaptureRequest.CONTROL_MODE, CameraMetadata.Control.CONTROL_MODE_AUTO_EXPOSURE);
        try {
            cameraCaptureSessions.setRepeatingRequest(captureRequestBuilder.build(), null, mBackgroundHandler);
        } catch (CameraAccessException e) {
            e.printStackTrace();
        }
    }

    //此方法负责配置TextureView的变换矩阵，以确保预览画面正确显示
    private void configureTransform(int viewWidth, int viewHeight) {
        if (null == textureView || null == previewSize) {
            return;
        }
        int rotation = getWindowManager().getDefaultDisplay().getRotation();
        Matrix 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);
    }

    @Override
    protected void onResume() {
        super.onResume();
        startBackgroundThread();

        // When the activity is in foreground, start camera and view preview
        if (textureView != null) {
            textureView.setSurfaceTextureListener(textureListener);
        }
    }

    @Override
    protected void onPause() {
        stopBackgroundThread();

        // When the activity is in background, stop the preview
        if (null != textureView) {
            textureView.setSurfaceTextureListener(null);
        }
        super.onPause();
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        handler.removeCallbacks(captureRunnable);
    }

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

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

    /*请求权限结果反馈*/
    @Override
    public void onRequestPermissionsResult(int requestCode, String[] permissions, int[] grantResults) {
        super.onRequestPermissionsResult(requestCode, permissions, grantResults);
        switch (requestCode) {
            case PERMISSION_REQUEST_CODE:
                /*PackageManager.PERMISSION_GRANTED  权限被许可*/
                /*PackageManager.PERMISSION_DENIED  没有权限；拒绝访问*/
                if (grantResults[0] != PackageManager.PERMISSION_GRANTED) {
                    Toast.makeText(this, "无法写入内存", Toast.LENGTH_SHORT).show();
                } else if (grantResults[1] != PackageManager.PERMISSION_GRANTED) {
                    Toast.makeText(this, "无法读取内存", Toast.LENGTH_SHORT).show();
                } else if (grantResults[2] != PackageManager.PERMISSION_GRANTED) {
                    Toast.makeText(this, "无法使用相机", Toast.LENGTH_SHORT).show();
                }
                break;
            default:
                Toast.makeText(this, "权限获取失败", Toast.LENGTH_SHORT).show();
                break;
        }
    }
}

我是凡小一
关注
  • 3
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Camera2 API 预览实现
toufatebieduo的博客
08-08 1117
Camera2框架实现预览
Android Camera2 API preview record take picture
jzlhll123的专栏
06-15 2427
Android Camera2 API预览 拍照和录像 使用到的接口是Camera2，MediaRecorder，ImageReader， TODO 文章会在明天更新。
camera2 (api2)打开预览过程（二）
lin20080410的专栏
08-21 5752
使用camera的流程： openCamera() -&gt; applySettings() -&gt; setPreviewTexture() -&gt; startPreview() -&gt;autoFocus() -&gt; takePicture()。打开camera设备的大致过程：1，  实例化CameraModule对象，即mCurrentModule表示当前的module，默认是...
自定义带取景框的camera
ruancw的博客
04-12 7227
前言：公司项目需求，在图像信息采集时只采集肩部以上部位的图片（和我们平时的一寸证件照很像），首先想到的是用第三方的图片选择器，他们都自带裁剪功能，不过每次拍完照后的手动裁剪，结果老大说简化业务人员的操作，不过这也难不倒无所不能的程序猿，没有咱们可以new一个（女朋友）。言归正传，开启我们的自定义带取景框的camera... 转载链接：https://blog.csdn.net/ruancw/ar...
一篇文章学会Android Camera2 Api，实现自定义相机入门。
kanglong618的博客
06-15 5324
#前言 最近在做相机相关的项目，考虑到调用系统相机部分功能不能满足项目需求，于是考虑自定相机这一块，由于之前没有接触过自定义相机这一块，于是查阅了相关资料，结合自身实践，做一个简单的总结。#相关参考资料 &gt; 感谢下面文章提供的参考-   [android camera2 详解说明（一）](http://www.cnblogs.com/kingwild/articles/5422329.htm...
android camera2获取平台人脸识别坐标步骤详解
hipeboy的博客
02-23 1416
人脸识别技术已经很广泛了，那么我们如何在我们的应用中集成人脸识别呢？Google平台自带有人脸识别功能，下面我们看看如何实现： //人脸识别当然得打开摄像头 cManager = (CameraManager) getSystemService(Context.CAMERA_SERVICE); //open camera cManager.openCamera(cId, getCDeviceOpenCallback(), getCHandler()); /** * 初始化并获取相机开
Android NDK开发详解相机之Camera API
hnjzfwy的博客
11-14 509
原生开发套件 (NDK) 是一套工具，使您能够在 Android 应用中使用 C 和 C++ 代码，并提供众多平台库，您可使用这些平台库管理原生 activity 和访问实体设备组件，例如传感器和触控输入。NDK 可能不适合大多数 Android 编程初学者，这些初学者只需使用 Java 代码和框架 API 开发应用
Android相机预览设置适配及显示方式
淘系技术
06-25 2906
Android相机的部分工作原理。预览流程相机预览是Android Camera最常用的功能之一，它是很多功能重要的输入，例如扫码、AR等。一般而言，相机预览的整体流程，可以通过下图表示：...
android camera2自定义,Android 自定义Camera（二）
weixin_30569923的博客
05-25 245
通过上一篇 Android 自定义Camera(一) 的介绍，我们已经可以完成一个可拍照的基础demo， 当然其中也有很多要注意的细节问题，比如预览方向，设置预览比例和返回图片的比例等等问题，详情可以看上一篇博客，这次我会丰富相机的功能加入 闪光灯模式，正方形拍摄，延迟拍摄和前后摄像头切换功能，接下来就一个一个开始吧。(下面会有完整源码地址)闪光灯模式相机的闪光灯模式有三种， 自动，关闭， 打开，...
手机摄像头矩形取景框拍照的实现（android）
05-09
2. **SurfaceView与Preview**: 在Android中，摄像头预览通常通过SurfaceView进行显示。SurfaceView是一个特殊的视图，它创建了一个独立的Surface，可以在后台线程中进行渲染，适合用于视频预览和播放。我们需要创建...
camera实时预览 虹软动态实现人脸画框
04-02
在这个场景中，我们关注的是"人脸画框"功能，它能够实时在摄像头预览画面中定位并框出人脸位置，为用户带来直观的体验，常用于安全监控、社交应用、美颜相机等。 描述中的"libs里面包含facedetection.jar，face...
API调用摄像头抓拍照片存档pb9
11-30
在描述中提到的“带取景框”，意味着API可能还支持在用户界面上显示实时的摄像头预览。 3. **图像处理**：在捕获照片后，可能需要对图像进行一些处理，例如裁剪、缩放、旋转或者添加水印等，以满足特定的应用需求。...
Android 打开摄像头
03-20
Android提供了两种主要的方式来访问和控制摄像头：Camera API（旧版）和Camera2 API（新版）。对于简单的二维码扫描需求，通常使用Camera API就足够了，因为它相对简单且易于集成。Camera2 API则提供了更多的控制...
前端字符串将其分割成长度为 32 的子字符串数组
人与人之间最小的差别是智商，最大的差别是坚持。
08-19 395
要实现这个需求，可以编写一个简单的 JavaScript 函数来处理字符串并将其分割成长度为 32 的子字符串数组。将字符串切割后，对list数据进行数据处理。
【js】各类前端输入校验方法
galaxyJING的博客
08-21 350
【代码】【js】各类前端输入校验方法。
vue中定义一个url文件,在vue文件中引入
最新发布
weixin_65767506的博客
08-22 242
1.在src/utils文件夹下创建一个url.js。3.在其他vue文件中引入。2.url.js的内容为。4.在挂载时打印一下。打印出来就可以用了.
浅谈JavaScript 框架在现代 Web 开发中的作用
08-21 512
随着近年来 Web 开发的快速发展，JavaScript 框架已成为用于构建任何应用程序的强大、灵活和可扩展元素的重要实用程序。一些框架，如Angular、React、Vue.JS等，有助于以系统的方式处理固有的网站开发复杂性，以提高效率。它们提供已经为基本编程功能和常规任务编写的 JavaScript 代码，从而缩短了必要的原始编码时间。此外，它们还增加了 Web 应用程序的功能和交互性，从...
Camera2 API，使用相机预览时设置预览尺寸
05-25
在 Camera2 API 中，可以使用以下步骤设置相机预览尺寸： 1. 获取相机设备的 CameraCharacteristics。这可以通过 CameraManager.getCameraCharacteristics() 方法获取。 2. 从 CameraCharacteristics 中获取 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值