android获取摄像头焦距，并调焦

最新推荐文章于 2025-04-27 11:08:32 发布
最新推荐文章于 2025-04-27 11:08:32 发布
阅读量4.6k 收藏 8
点赞数 2
CC 4.0 BY-SA版权
分类专栏： 【android开发】 文章标签： android android studio webview
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/doubleintfloat/article/details/124714405
本文展示了如何在Android应用中实现手动对焦功能，通过XML布局配置TextureView，创建CameraCaptureSession，设置CaptureRequest，并使用SeekBar调整镜头焦距。在用户拖动SeekBar时，更新CaptureRequest中的LENS_FOCUS_DISTANCE，实现实时焦点变化。代码涵盖了从初始化相机到捕获图像的完整流程。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

不废话，上代码

<?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:layout_width="wrap_content"
    android:layout_height="wrap_content"
    tools:context=".MainActivity">


    <TextureView
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:id="@+id/textureView"
        android:layout_centerHorizontal="true"
        android:layout_centerVertical="true"/>



    <LinearLayout
        android:gravity="bottom"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content">
        <Button
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:text="拍照"
            android:gravity="center"
            android:id="@+id/photoButton"
            android:onClick="takePicture"
            android:layout_alignParentBottom="true"
            android:layout_centerHorizontal="true"/>


        <Button
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:text="-"
            android:id="@+id/sub"
            android:onClick="subfocus"
            android:layout_alignParentBottom="true"
            android:layout_centerHorizontal="true"/>

        <Button
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:text="+"
            android:id="@+id/add"
            android:onClick="addfocus"
            android:layout_alignParentBottom="true"
            android:layout_centerHorizontal="true"/>

        <SeekBar
            android:id="@+id/seekBar"
            android:layout_width="500dp"
            android:layout_height="match_parent"
            android:layout_marginTop="20dp"
            android:max="300"
            android:progress="100"/>
        <TextView
            android:id="@+id/tvProgress"
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:text="数值范围0~100之间，当前值：30"
            android:textSize="20sp"
            android:gravity="center"/>

    </LinearLayout>
</androidx.constraintlayout.widget.ConstraintLayout>

package com.example.focus2;

import androidx.annotation.RequiresApi;
import androidx.appcompat.app.AppCompatActivity;
import androidx.core.app.ActivityCompat;

import android.os.Build;
import android.os.Bundle;


        import android.Manifest;
        import android.app.Activity;
        import android.content.Context;
        import android.content.pm.PackageManager;
        import android.graphics.ImageFormat;
        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.CameraMetadata;
        import android.hardware.camera2.CaptureRequest;
        import android.hardware.camera2.CaptureResult;
        import android.hardware.camera2.TotalCaptureResult;
        import android.hardware.camera2.params.StreamConfigurationMap;
        import android.media.Image;
        import android.media.ImageReader;
        import android.os.Bundle;
        import android.os.Environment;
        import android.os.Handler;
        import android.os.HandlerThread;
import android.util.Log;
import android.util.Size;
        import android.util.SparseIntArray;
        import android.view.Surface;
        import android.view.TextureView;
        import android.view.View;
        import android.view.Window;
        import android.view.WindowManager;
import android.widget.SeekBar;
import android.widget.TextView;
import android.widget.Toast;

        import java.io.File;
        import java.io.FileOutputStream;
        import java.io.IOException;
        import java.nio.ByteBuffer;
        import java.text.SimpleDateFormat;
        import java.util.ArrayList;
        import java.util.Arrays;
        import java.util.Collections;
        import java.util.Comparator;
        import java.util.Date;
        import java.util.List;

public class MainActivity extends Activity {
    private static final SparseIntArray ORIENTATION = new SparseIntArray();

    static {
        ORIENTATION.append(Surface.ROTATION_0, 90);
        ORIENTATION.append(Surface.ROTATION_90, 0);
        ORIENTATION.append(Surface.ROTATION_180, 270);
        ORIENTATION.append(Surface.ROTATION_270, 180);
    }

    static float m_len =0.0f;
    private String mCameraId;
    private Size mPreviewSize;
    private Size mCaptureSize;
    private HandlerThread mCameraThread;
    private Handler mCameraHandler;
    private CameraDevice mCameraDevice;
    private TextureView mTextureView;
    private ImageReader mImageReader;
    private CaptureRequest.Builder mCaptureRequestBuilder;
    private CaptureRequest mCaptureRequest;
    private CameraCaptureSession mCameraCaptureSession;

    private SeekBar seekBar;
    private TextView tvProgress;


    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

        //全屏无状态栏
        getWindow().setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN, WindowManager.LayoutParams.FLAG_FULLSCREEN);
        requestWindowFeature(Window.FEATURE_NO_TITLE);

        setContentView(R.layout.activity_main);
        mTextureView = (TextureView) findViewById(R.id.textureView);


        seekBar = findViewById(R.id.seekBar);
        tvProgress = findViewById(R.id.tvProgress);
        //注册拖动监听器
        seekBar.setOnSeekBarChangeListener(new SeekBar.OnSeekBarChangeListener() {
            @Override
            public void onProgressChanged(SeekBar seekBar, int progress, boolean fromUser) {
                //将seekBar的进度设置在textView上
                tvProgress.setText("当前值："+progress);
            }

            @Override
            public void onStartTrackingTouch(SeekBar seekBar) {
                int m_pos = seekBar.getProgress();
                float f_pos= m_pos;
                f_pos = f_pos/10;


                mCaptureRequestBuilder.set(CaptureRequest.CONTROL_AF_MODE, CaptureRequest.CONTROL_AF_MODE_OFF);
                mCaptureRequestBuilder.set(CaptureRequest.LENS_FOCUS_DISTANCE, f_pos);

                updatePreview(mCameraCaptureSession);

                String ls = CameraCharacteristics.LENS_INFO_FOCUS_DISTANCE_CALIBRATION.toString();

                float tt = mCaptureRequestBuilder.get(CaptureRequest.LENS_FOCUS_DISTANCE);
                float tt1 = mCaptureRequestBuilder.get(CaptureRequest.LENS_FOCAL_LENGTH);


                Log.e("---CaptureRequest.LENS_FOCUS_DISTANCE = ", Float.toString(tt));

            }

            @Override
            public void onStopTrackingTouch(SeekBar seekBar) {
                int m_pos = seekBar.getProgress();
                float f_pos= m_pos;
                f_pos = f_pos/10;


                mCaptureRequestBuilder.set(CaptureRequest.CONTROL_AF_MODE, CaptureRequest.CONTROL_AF_MODE_OFF);
                mCaptureRequestBuilder.set(CaptureRequest.LENS_FOCUS_DISTANCE, f_pos);

                updatePreview(mCameraCaptureSession);

                float tt = mCaptureRequestBuilder.get(CaptureRequest.LENS_FOCUS_DISTANCE);


                Log.e("---CaptureRequest.LENS_FOCUS_DISTANCE = ", Float.toString(tt));

            }
        });

    }

    @Override
    protected void onResume() {
        super.onResume();
        startCameraThread();
        if (!mTextureView.isAvailable()) {
            mTextureView.setSurfaceTextureListener(mTextureListener);
        } else {
            startPreview();
        }
    }

    private void startCameraThread() {
        mCameraThread = new HandlerThread("CameraThread");
        mCameraThread.start();
        mCameraHandler = new Handler(mCameraThread.getLooper());
    }

    private TextureView.SurfaceTextureListener mTextureListener = new TextureView.SurfaceTextureListener() {
        @Override
        public void onSurfaceTextureAvailable(SurfaceTexture surface, int width, int height) {
            //当SurefaceTexture可用的时候，设置相机参数并打开相机
            setupCamera(width, height);
            openCamera();
        }

        @Override
        public void onSurfaceTextureSizeChanged(SurfaceTexture surface, int width, int height) {

        }

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

        @Override
        public void onSurfaceTextureUpdated(SurfaceTexture surface) {

        }
    };

    @RequiresApi(api = Build.VERSION_CODES.P)
    private void setupCamera(int width, int height) {
        //获取摄像头的管理者CameraManager
        CameraManager manager = (CameraManager) getSystemService(Context.CAMERA_SERVICE);
        try {
            //遍历所有摄像头
            for (String cameraId : manager.getCameraIdList()) {
                CameraCharacteristics characteristics = manager.getCameraCharacteristics(cameraId);

                CameraCharacteristics.Key<Integer> yourMinFocus = CameraCharacteristics.LENS_INFO_FOCUS_DISTANCE_CALIBRATION;
//                float yourMaxFocus = CameraCharacteristics.get(CameraCharacteristics.LENS_INFO_HYPERFOCAL_disTANCE);
                Integer facing = characteristics.get(CameraCharacteristics.LENS_FACING);
                //此处默认打开后置摄像头
                if (facing != null && facing == CameraCharacteristics.LENS_FACING_FRONT)
                    continue;
                //获取StreamConfigurationMap，它是管理摄像头支持的所有输出格式和尺寸
                StreamConfigurationMap map = characteristics.get(CameraCharacteristics.SCALER_STREAM_CONFIGURATION_MAP);
                assert map != null;
                //根据TextureView的尺寸设置预览尺寸
                mPreviewSize = getOptimalSize(map.getOutputSizes(SurfaceTexture.class), width, height);
                //获取相机支持的最大拍照尺寸
                mCaptureSize = Collections.max(Arrays.asList(map.getOutputSizes(ImageFormat.JPEG)), new Comparator<Size>() {
                    @Override
                    public int compare(Size lhs, Size rhs) {
                        return Long.signum(lhs.getWidth() * lhs.getHeight() - rhs.getHeight() * rhs.getWidth());
                    }
                });
                //此ImageReader用于拍照所需
                setupImageReader();
                mCameraId = cameraId;
                break;
            }
        } catch (CameraAccessException e) {
            e.printStackTrace();
        }
    }

    //选择sizeMap中大于并且最接近width和height的size
    private Size getOptimalSize(Size[] sizeMap, int width, int height) {
        List<Size> sizeList = new ArrayList<>();
        for (Size option : sizeMap) {
            if (width > height) {
                if (option.getWidth() > width && option.getHeight() > height) {
                    sizeList.add(option);
                }
            } else {
                if (option.getWidth() > height && option.getHeight() > width) {
                    sizeList.add(option);
                }
            }
        }
        if (sizeList.size() > 0) {
            return Collections.min(sizeList, new Comparator<Size>() {
                @Override
                public int compare(Size lhs, Size rhs) {
                    return Long.signum(lhs.getWidth() * lhs.getHeight() - rhs.getWidth() * rhs.getHeight());
                }
            });
        }
        return sizeMap[0];
    }


    private void openCamera() {
        CameraManager manager = (CameraManager) getSystemService(Context.CAMERA_SERVICE);
        try {
            if (ActivityCompat.checkSelfPermission(this, Manifest.permission.CAMERA) != PackageManager.PERMISSION_GRANTED) {
                return;
            }
            manager.openCamera(mCameraId, mStateCallback, mCameraHandler);
            CameraCharacteristics.Key<Integer> yourMinFocus = CameraCharacteristics.LENS_INFO_FOCUS_DISTANCE_CALIBRATION;

             int mCameraId = CameraCharacteristics.LENS_FACING_FRONT; // 要打开的摄像头ID
             CameraCharacteristics mCameraCharacteristics; // 相机属性
            CameraManager mCameraManager = (CameraManager) getSystemService(Context.CAMERA_SERVICE);

            mCameraCharacteristics = mCameraManager.getCameraCharacteristics(Integer.toString(mCameraId));
            StreamConfigurationMap map = mCameraCharacteristics.get(CameraCharacteristics.SCALER_STREAM_CONFIGURATION_MAP);
            float yourMinFocus1[] = (float[]) mCameraCharacteristics.get(CameraCharacteristics.LENS_INFO_AVAILABLE_FOCAL_LENGTHS);
            Log.d("---" , Float.toString(yourMinFocus1[0]));

            new Thread() {
                public void run() {
                    while (true) {
                        runOnUiThread(new Runnable() {
                            @Override
                            public void run() {
                                float []distances = new float[3];

                                float yourMinFocus1[] = (float[]) mCameraCharacteristics.get(CameraCharacteristics.LENS_INFO_AVAILABLE_FOCAL_LENGTHS);
                                float yourMinFocus2[] = (float[]) mCameraCharacteristics.get(CameraCharacteristics.LENS_INFO_AVAILABLE_FILTER_DENSITIES);
                                int yourMinFocus3 =  mCameraCharacteristics.get(CameraCharacteristics.LENS_INFO_FOCUS_DISTANCE_CALIBRATION);

//                                Log.d("1---" , Float.toString(yourMinFocus1[0]));
//                                Log.d("2---" , Float.toString(yourMinFocus2[0]));
//                                Log.d("3---" , Integer.toString(yourMinFocus3));


//                                m_len+=0.3f;
//                                mCaptureRequestBuilder.set(CaptureRequest.CONTROL_AF_MODE, CaptureRequest.CONTROL_AF_MODE_OFF);
//                                mCaptureRequestBuilder.set(CaptureRequest.LENS_FOCUS_DISTANCE, m_len);
//                                Log.d("4---" , Float.toString(m_len));
//                                Log.d("5---" , (CaptureRequest.LENS_FOCUS_DISTANCE).toString());
//                                Log.d("6---" , CaptureRequest.LENS_FOCAL_LENGTH.toString());
//                                updatePreview(mCameraCaptureSession);
//
//                                float tt = mCaptureRequestBuilder.get(CaptureRequest.LENS_FOCUS_DISTANCE);
//
//
//                                Log.e("7---", Float.toString(tt));

//                                startPreview();

//                                mCaptureRequestBuilder.get(CaptureRequest.LENS_FOCUS_DISTANCE, m_len);



                            }
                        });
                        try {
                            Thread.sleep(1000);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                }
            }.start();


            Log.d("------" ,yourMinFocus.toString() );
        } catch (CameraAccessException e) {
            e.printStackTrace();
        }
    }

    private void updatePreview(CameraCaptureSession session) {
        try {
            session.setRepeatingRequest(mCaptureRequestBuilder.build(), null, mCameraHandler);

        } catch (CameraAccessException e) {
            e.printStackTrace();
        } catch (IllegalStateException e) {
            e.printStackTrace();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }


    private CameraDevice.StateCallback mStateCallback = new CameraDevice.StateCallback() {
        @Override
        public void onOpened(CameraDevice camera) {
            mCameraDevice = camera;
            startPreview();
        }

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

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

    private void startPreview() {
        Log.d("-----------" , "startPreview");
        SurfaceTexture mSurfaceTexture = mTextureView.getSurfaceTexture();
        mSurfaceTexture.setDefaultBufferSize(mPreviewSize.getWidth(), mPreviewSize.getHeight());
        Surface previewSurface = new Surface(mSurfaceTexture);
        try {
            mCaptureRequestBuilder = mCameraDevice.createCaptureRequest(CameraDevice.TEMPLATE_PREVIEW);
            mCaptureRequestBuilder.addTarget(previewSurface);
            mCameraDevice.createCaptureSession(Arrays.asList(previewSurface, mImageReader.getSurface()), new CameraCaptureSession.StateCallback() {
                @Override
                public void onConfigured(CameraCaptureSession session) {
                    try {
                        mCaptureRequest = mCaptureRequestBuilder.build();
                        mCameraCaptureSession = session;
                        mCameraCaptureSession.setRepeatingRequest(mCaptureRequest, null, mCameraHandler);
                        Log.d("-----------" , "startPreview");
                    } catch (CameraAccessException e) {
                        e.printStackTrace();
                    }
                }

                @Override
                public void onConfigureFailed(CameraCaptureSession session) {

                }
            }, mCameraHandler);
        } catch (CameraAccessException e) {
            e.printStackTrace();
        }
    }

    public void takePicture(View view) {
        lockFocus();
        Log.d("-----------" , "take");
    }

    public void subfocus(View view)
    {
        m_len=mCaptureRequestBuilder.get(CaptureRequest.LENS_FOCUS_DISTANCE);
        m_len-=0.3f;

        mCaptureRequestBuilder.set(CaptureRequest.CONTROL_AF_MODE, CaptureRequest.CONTROL_AF_MODE_OFF);
        mCaptureRequestBuilder.set(CaptureRequest.LENS_FOCUS_DISTANCE, m_len);

        updatePreview(mCameraCaptureSession);

        float tt = mCaptureRequestBuilder.get(CaptureRequest.LENS_FOCUS_DISTANCE);


        Log.e("---CaptureRequest.LENS_FOCUS_DISTANCE = ", Float.toString(tt));

    }

    public void addfocus(View view)
    {
        m_len =mCaptureRequestBuilder.get(CaptureRequest.LENS_FOCUS_DISTANCE);
        m_len+=0.3f;

        mCaptureRequestBuilder.set(CaptureRequest.CONTROL_AF_MODE, CaptureRequest.CONTROL_AF_MODE_OFF);
        mCaptureRequestBuilder.set(CaptureRequest.LENS_FOCUS_DISTANCE, m_len);

        updatePreview(mCameraCaptureSession);

        float tt = mCaptureRequestBuilder.get(CaptureRequest.LENS_FOCUS_DISTANCE);


        Log.e("---CaptureRequest.LENS_FOCUS_DISTANCE = ", Float.toString(tt));
    }

    private void lockFocus() {
        try {
            mCaptureRequestBuilder.set(CaptureRequest.CONTROL_AF_TRIGGER, CameraMetadata.CONTROL_AF_TRIGGER_START);
            mCameraCaptureSession.capture(mCaptureRequestBuilder.build(), mCaptureCallback, mCameraHandler);
        } catch (CameraAccessException e) {
            e.printStackTrace();
        }
    }

    private CameraCaptureSession.CaptureCallback mCaptureCallback = new CameraCaptureSession.CaptureCallback() {
        @Override
        public void onCaptureProgressed(CameraCaptureSession session, CaptureRequest request, CaptureResult partialResult) {
        }

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

    private void capture() {
        try {
            final CaptureRequest.Builder mCaptureBuilder = mCameraDevice.createCaptureRequest(CameraDevice.TEMPLATE_STILL_CAPTURE);
            int rotation = getWindowManager().getDefaultDisplay().getRotation();
            mCaptureBuilder.addTarget(mImageReader.getSurface());
            mCaptureBuilder.set(CaptureRequest.JPEG_ORIENTATION, ORIENTATION.get(rotation));
            CameraCaptureSession.CaptureCallback CaptureCallback = new CameraCaptureSession.CaptureCallback() {
                @Override
                public void onCaptureCompleted(CameraCaptureSession session, CaptureRequest request, TotalCaptureResult result) {
                    Toast.makeText(getApplicationContext(), "Image Saved!", Toast.LENGTH_SHORT).show();
                    unLockFocus();
                }
            };
            mCameraCaptureSession.stopRepeating();
            mCameraCaptureSession.capture(mCaptureBuilder.build(), CaptureCallback, null);
        } catch (CameraAccessException e) {
            e.printStackTrace();
        }
    }

    private void unLockFocus() {
        try {
            mCaptureRequestBuilder.set(CaptureRequest.CONTROL_AF_TRIGGER, CameraMetadata.CONTROL_AF_TRIGGER_CANCEL);
            //mCameraCaptureSession.capture(mCaptureRequestBuilder.build(), null, mCameraHandler);
            mCameraCaptureSession.setRepeatingRequest(mCaptureRequest, null, mCameraHandler);
        } catch (CameraAccessException e) {
            e.printStackTrace();
        }
    }

    @Override
    protected void onPause() {
        super.onPause();
        if (mCameraCaptureSession != null) {
            mCameraCaptureSession.close();
            mCameraCaptureSession = null;
        }

        if (mCameraDevice != null) {
            mCameraDevice.close();
            mCameraDevice = null;
        }

        if (mImageReader != null) {
            mImageReader.close();
            mImageReader = null;
        }
    }

    private void setupImageReader() {
        //2代表ImageReader中最多可以获取两帧图像流
        mImageReader = ImageReader.newInstance(mCaptureSize.getWidth(), mCaptureSize.getHeight(),
                ImageFormat.JPEG, 2);
        mImageReader.setOnImageAvailableListener(new ImageReader.OnImageAvailableListener() {
            @Override
            public void onImageAvailable(ImageReader reader) {
                mCameraHandler.post(new imageSaver(reader.acquireNextImage()));
            }
        }, mCameraHandler);
    }

    public static class imageSaver implements Runnable {

        private Image mImage;

        public imageSaver(Image image) {
            mImage = image;
        }

        @Override
        public void run() {
            ByteBuffer buffer = mImage.getPlanes()[0].getBuffer();
            byte[] data = new byte[buffer.remaining()];
            buffer.get(data);
            String path = Environment.getExternalStorageDirectory() + "/DCIM/CameraV2/";
            File mImageFile = new File(path);
            if (!mImageFile.exists()) {
                mImageFile.mkdir();
            }
            String timeStamp = new SimpleDateFormat("yyyyMMdd_HHmmss").format(new Date());
            String fileName = path + "IMG_" + timeStamp + ".jpg";
            FileOutputStream fos = null;
            try {
                fos = new FileOutputStream(fileName);
                fos.write(data, 0, data.length);
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                if (fos != null) {
                    try {
                        fos.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    }
}
android 开发相机焦距解析之调节远近焦距
likesyour的博客
05-26 1万+
我的csdn 官方博客 ：http://my.youkuaiyun.com/likesyour          小弟初来乍到-
Android 摄像头调用（不含拍照），神操作
m0_66145114的博客
01-24 431
camera.setDisplayOrientation(result); //设置拍摄角度 } 然后设置焦距和打开的竖屏横屏 private void setCamera(){ if(checkCameraHadware()){ camera = openFrontFacingCameraGingerbread(); //设置摄像头方向调整摄像头旋转90度，成竖屏 setCameraDisplayOrientation(this,mCurrentCamIndex,camera); Camer
android相机固定焦距,如何找到Android相机的焦距？
weixin_35906794的博客
05-25 819
我使用stackoverflow和google.I需要计算我的相机和指定对象之间的距离.为此,我需要找到我的相机的焦距.我也创建了示例项目,但它创建了Null Pointer Exception.请帮助..代码如下.public class MainActivity extends Activity {Camera mcamera;int focul_length;Parameters param...
Android拍照测距实用项目实战
最新发布
weixin_42360733的博客
04-27 426
参照物法测距是一种简单而有效的距离测量方法，它依赖于一个已知尺寸的参照物来推算目标物体与相机之间的距离。这种方法常用于计算机视觉和机器人导航等应用中。Camera API是Android系统提供的用于控制摄像头的一套接口，通过这些API，应用可以获取预览图像流、拍照、录像等。从Android 5.0 (API 级别 21)开始，引入了Camera2 API，带来了更多的功能和更好的性能，包括支持手动控制参数、高级对焦模式等。
android Camera 设置焦距
meixi_android的博客
11-26 8998
1、添加Camera权限 2、判断是否支持变焦 public boolean isSupportZoom() { boolean isSuppport = true; if (mCamera.getParameters().isSmoothZoomSupported()) { isSuppport = fal...
android 点击后获取焦距使用
923723914
06-25 666
button1.setFocusableInTouchMode(true); button1.requestFocus();
2024年安卓最新安卓学习笔记---开篇（目录结构），2024年最新软件开发面试题及答案
2301_82244182的博客
05-08 586
找到一套好的视频资料，紧跟大牛梳理好的知识框架进行学习。多练。（视频优势是互动感强，容易集中注意力）你不需要是天才，也不需要具备强悍的天赋，只要做到这两点，短期内成功的概率是非常高的。对于很多初中级Android工程师而言，想要提升技能，往往是自己摸索成长，不成体系的学习效果低效漫长且无助。
Android 摄像头聚焦
自我学习 自我整理
04-06 166
public AutoFocusCallback mAutoFocusCallback = new AutoFocusCallback();   public final class AutoFocusCallback implements android.hardware.Camera.AutoFocusCallback { public void onAutoFocus(bo...
android camera 对焦大小,Android camera2对焦设置
weixin_35355756的博客
05-25 1778
在android camera2 api 开始，提供了对焦距值(非zoom值)的设置，大概步骤如下：(1)先关闭自动焦距模式 mPreviewBuilder.set(CaptureRequest.CONTROL_AE_MODE,CameraMetadata.CONTROL_AE_MODE_OFF);mPreviewBuilder.set(CaptureRequest.CONTROL_AF_...
android opencv 数码变焦,Android开发(53) 摄像头自动对焦。在OpenCV图像识别中连续拍照时自动对焦和拍照。......
weixin_35755562的博客
05-27 936
概述对焦，这里所说的“焦”是指“焦距”。在拍照时，一定是需要调焦的。一般会在目标位置最清晰的时候会停止对焦。最近在处理OpenCV进行图像识别时，需要连续的调焦(对焦)，并在对焦完成后进行拍照，获取图片后进行图像识别。识别完成后摄像头不关闭继续进行扫描识别。整理成本文。概念焦距，也称为焦长，是光学系统中衡量光的聚集或发散的度量方式，指从透镜中心到光聚集之焦点的距离。亦是照相机中，从镜片光学中心到底...
Android 摄像头调用（不含拍照），Android面试基础知识
m0_65145113的博客
12-28 184
Camera.CameraInfo info = new Camera.CameraInfo(); Camera.getCameraInfo(cameraId,info); //获得旋转角度 int rotation = activity.getWindowManager().getDefaultDisplay().getRotation(); int degrees = 0; switch (rotation) { case Surface.ROTATION_0: //没有旋转 degr
Android自定义相机，触摸聚焦，点击聚焦 手动聚焦
09-02
自定义相机，并且以View形式显示，可以随便添加到应用中，实现手动聚焦，触摸聚焦
Android实现手机摄像头的自动对焦
09-01
主要为大家详细介绍了Android实现手机摄像头的自动对焦的相关资料,具有一定的参考价值，感兴趣的小伙伴们可以参考一下
Android 摄像头调用（不含拍照），不吃透都对不起自己
m0_64604178的博客
12-21 403
private int mCurrentCamIndex; //相机的指数 private int ROTATE; //旋转值 private int minFocus; //当前手机默认的焦距 private int maxFocus; //当前手机的最大焦距 private int everyFocus; //用于调整焦距 private int nowFocus; //当前的焦距值 private
安卓使用uvc协议调用usb外接摄像头
xzdjsnb的博客
06-17 942
目前比较简单直接拉取就可以使用的是UVCAndroid这个项目源码。其他的只要你们能搜索到，我都尝试了，要不是libusb这个编译不出来，要不就是缺少ndk。Java 自带的camera api只能获取简单的拍摄，无法实现类似手机的调倍数和调焦距。自己使用github上项目为大家试试能不能成功。我的需求是，用代码页面滚动条控制摄像头的参数。可以运行成功，对一些没那么高要求的摄像头还是没问题的。可以运行成功，对一些没那么高要求的摄像头还是没问题的。我接下来试试用ndk看可以运行成功不。
android相机固定焦距,android Camera 设置焦距
weixin_30310209的博客
05-25 2444
1、添加Camera权限2、判断是否支持变焦 public boolean isSupportZoom(){boolean isSuppport = true;if (mCamera.getParameters().isSmoothZoomSupported()){isSuppport = false;}return isSuppport;} 3、修改焦距 public void setZoom(...
android相机固定焦距,Android Camera变焦编程步骤
weixin_35322457的博客
05-25 478
public void setZoom(){if (mIsSupportZoom){try{Parameters params = mCamera.getParameters();final int MAX = params.getMaxZoom();if(MAX==0)return;int zoomValue = params.getZoom();Trace.Log("-------------...
Android架构师成长路线，从不一样的角度描述Android事件传递
A1867350的博客
03-07 407
其实Android开发的知识点就那么多，面试问来问去还是那么点东西。所以面试没有其他的诀窍，只看你对这些知识点准备的充分程度。so，出去面试时先看看自己复习到了哪个阶段就好。上面分享的腾讯、头条、阿里、美团、字节跳动等公司2019-2021年的高频面试题，博主还把这些技术点整理成了视频和PDF（实际上比预期多花了不少精力），包含知识脉络 + 诸多细节，由于篇幅有限，上面只是以图片的形式给大家展示一部分。【Android思维脑图（技能树）】知识不体系？
android相机固定焦距,android - Android相机焦距和焦距不变 - 堆栈内存溢出
weixin_39827315的博客
05-25 306
我试图检测相机自动对焦时会改变的值，我希望焦距和焦距会改变。 我已经使用FOCUS_MODE_CONTINUOUS_PICTURE运行了我的应用程序。 自动对焦有效，我每秒调用一次getFocalLength()来查看值的变化，无论我移动相机多少，我总是得到4.6。 我也尝试过getFocusDistances()，它一直为所有3个输出返回无穷大。当焦点改变时，这些函数返回的值应该改变，但是...
opencv获取摄像头焦距
01-18
在OpenCV中，获取摄像头的焦距可以通过测量目标物体与摄像头之间的距离以及图像上目标的像素宽度来间接实现。这个过程通常涉及以下几个步骤[^1]： 1. **测量目标物宽度**: 首先，你需要找到图像上的某个已知尺寸的目标（如一个标记），其实际宽度是已知的。 2. **距离计算**: 使用`distance_to_camera`函数，该函数接受三个参数：已知目标宽度（knownWidth）、假设的焦距（focalLength）（这通常是根据相机规格预先设定的），以及目标在图像上的像素宽度（perWidth）。这个函数基于相似三角形原理计算目标到相机的距离。 3. **获取焦距**: 如果你知道目标的实际宽度和它在图像上的像素宽度，你可以调用`distance_to_camera`函数来反推出焦距。然而，注意这不是真正的摄像机标定，摄像机标定涉及到更复杂的内参信息。 具体操作示例代码可能如下所示（Python接口可能有所不同，但概念不变）: ```python # 假设你已经有了目标宽度（knownWidth）和图像上的像素宽度(perWidth) knownWidth = ... # 实际宽度 perWidth = ... # 目标在图像上的像素宽度 # 假设你已经从文档或相机规格中得到了focalLength focalLength = ... # 计算距离 camera_distance = distance_to_camera(knownWidth, focalLength, perWidth) # 注意：上述步骤仅适用于特定情况，完整的焦距计算通常依赖于更详细的摄像机参数设置 ```
评论 5
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值