🤟🏾 🏑 🐼 चकाचौंध दृष्टि का चश्मा। मेकर पार्ट 5 फ्लैश से एंड्रॉइड कैमरा 2 एपीआई 🙎 👼 😻

तकनीकी सफलताओं और उपलब्धियों के युग में रहते हुए, यह देखते हुए कि कैसे मास्क और बेजोस रॉकेट आकाश में भागते हैं, हम, उच्च तकनीकी शिक्षा वाले सामान्य लोग, अक्सर एक सफलता बनाने की संभावना पर ध्यान नहीं देते हैं, अंतरिक्ष में नहीं, लेकिन यहां हमारे बगल में, सचमुच मेज से ~~सोफे~~ से उठना नहीं ।

खुद के लिए न्यायाधीश क्या खोज आधुनिक स्मार्टफोन के बारे में एक नियमित लेख पढ़ने के लिए नेतृत्व कर सकते हैं। मैं स्रोत नहीं दूंगा, ताकि भविष्य की आय को साझा न कर सकूं।

, , . « » Google Pixel. IT RAW, HDR-, «», . Pixel 4 «Night Sight» . : , . , .

एक और बात यह है कि रात में चलना और मोबाइल फोन की स्क्रीन पर स्क्रब करना किसी तरह असहज है, यहां तक कि रात के मोड में भी। और फिर मेरी नजर गलती से एक शेल्फ पर पड़े स्मार्टफोन के वीआर-हेडसेट पर पड़ी। सफलता सच हो गई है! यह केवल रहता है, इसका उपयोग करते हुए और एंड्रॉइड कैमरा 2 एपीआई के बारे में चार पदों पर संचित ज्ञान, "नाइट साइट" से छवि को सीधे आंखों में निर्देशित करने के लिए। उसी समय, एक अंधेरे कमरे में काली बिल्ली को पकड़ने के लिए हाथ मुक्त होंगे। प्रकाश के बिना, ज़ाहिर है, यह काम नहीं करेगा, फोटॉनों, कम से कम थोड़ा, लेकिन यह आवश्यक है। लेकिन कम से कम हमें अंधेरे में कोटन के झाँकों के स्तर तक (या उससे भी आगे) पहुँचना चाहिए।

इसलिए, यह जानने के लिए कि अंधेरे में कैसे देखना है, हमें इसकी आवश्यकता है:

1: स्मार्टफोन के लिए एक वर्चुअल रियलिटी हेडसेट, (सबसे सस्ता संभव)

2: एक कैमरा (अच्छी तरह से, यह निश्चित रूप से सबसे सस्ता नहीं होगा)

: कैमरा Camera2 एपीआई की मूल बातों का ज्ञान (हमारे पास पहले से ही है)

भाग एक
भाग दो
भाग तीन
भाग चार

हम एंड्रॉइड स्टूडियो में एक नई परियोजना खोलते हैं और कोड को मूर्तिकला करना शुरू करते हैं।

पहली बात यह है कि वास्तविक वीआर सतह को इकट्ठा करना है जो हेडसेट में चमक जाएगा।

ख़ाका

<?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="match_parent"
    android:layout_height="match_parent"
    android:background="#03061B"
    tools:context=".MainActivity">

    <TextureView
        android:id="@+id/textureView"
        android:layout_width="240dp"
        android:layout_height="320dp"
        android:layout_marginTop="28dp"
        app:layout_constraintEnd_toEndOf="parent"
        app:layout_constraintHorizontal_bias="0.497"
        app:layout_constraintStart_toStartOf="parent"
        app:layout_constraintTop_toTopOf="parent" />

    <TextureView
        android:id="@+id/textureView3"
        android:layout_width="240dp"
        android:layout_height="320dp"
        android:layout_marginTop="16dp"
        app:layout_constraintEnd_toEndOf="parent"
        app:layout_constraintStart_toStartOf="parent"
        app:layout_constraintTop_toBottomOf="@+id/textureView" />

    <LinearLayout
        android:layout_width="165dp"
        android:layout_height="40dp"
        app:layout_constraintBottom_toBottomOf="parent"
        app:layout_constraintEnd_toEndOf="parent"
        app:layout_constraintStart_toStartOf="parent"
        app:layout_constraintTop_toBottomOf="@+id/textureView3"
        app:layout_constraintVertical_bias="0.838">

        <Button
            android:id="@+id/button1"
            android:layout_width="wrap_content"
            android:layout_height="36dp"
            android:backgroundTint="#3F51B5"
            android:text=""
            android:textColor="#1A87DD" />

        <Button
            android:id="@+id/button3"
            android:layout_width="wrap_content"
            android:layout_height="37dp"
            android:backgroundTint="#3F51B5"
            android:text=""
            android:textColor="#2196F3" />
    </LinearLayout>


</androidx.constraintlayout.widget.ConstraintLayout>

आउटपुट में कुछ इस तरह होना चाहिए:

जैसा कि आप देख सकते हैं, बनावट आयताकार हो गई, जबकि स्मार्टफोन के लिए किसी भी वीआर खिलौने में, डेवलपर्स किसी तरह उन्हें गोल करने के लिए प्रबंधन करते हैं। लेकिन हम इस पर ध्यान नहीं देंगे। आगे का अनुभव अभी भी दिखाएगा कि यह करेगा।

इसके लिए, वास्तव में, हम एक मामूली गतिविधि लिखते हैं, जिसमें पिछले लेखों से सब कुछ पहले से ही परिचित है।

package com.example.twovideosurfaces;
import androidx.annotation.RequiresApi;
import androidx.appcompat.app.AppCompatActivity;
import androidx.core.content.ContextCompat;
import android.Manifest;
import android.content.Context;
import android.content.pm.ActivityInfo;
import android.content.pm.PackageManager;
import android.graphics.SurfaceTexture;
import android.hardware.camera2.CameraAccessException;
import android.hardware.camera2.CameraCaptureSession;
import android.hardware.camera2.CameraDevice;
import android.hardware.camera2.CameraManager;
import android.hardware.camera2.CaptureRequest;
import android.os.Build;
import android.os.Bundle;
import android.os.Handler;
import android.os.HandlerThread;
import android.os.StrictMode;
import android.util.Log;
import android.view.Surface;
import android.view.TextureView;
import android.view.View;
import android.widget.Button;
import java.util.Arrays;
public class MainActivity extends AppCompatActivity  {
    public static final String LOG_TAG = "myLogs";
    public static Surface surface1 = null;
    public static Surface surface2 = null;
    CameraService[] myCameras = null;
    private CameraManager mCameraManager = null;
    private final int CAMERA1 = 0;
    private Button mOn = null;
    private Button mOff = null;
    public static TextureView mImageViewUp = null;
    public static TextureView mImageViewDown = null;
    private HandlerThread mBackgroundThread;
    private Handler mBackgroundHandler = null;
    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();
        }
    }
    @RequiresApi(api = Build.VERSION_CODES.M)
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        StrictMode.ThreadPolicy policy = new StrictMode.ThreadPolicy.Builder().permitAll().build();
        StrictMode.setThreadPolicy(policy);
        setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT);
        setContentView(R.layout.activity_main);
        Log.d(LOG_TAG, " ");
        if (checkSelfPermission(Manifest.permission.CAMERA) != PackageManager.PERMISSION_GRANTED
                ||
                (ContextCompat.checkSelfPermission(MainActivity.this, Manifest.permission.WRITE_EXTERNAL_STORAGE) != PackageManager.PERMISSION_GRANTED)
        ) {
            requestPermissions(new String[]{Manifest.permission.CAMERA, Manifest.permission.WRITE_EXTERNAL_STORAGE}, 1);
        }
        mOn = findViewById(R.id.button1);
        mOff = findViewById(R.id.button3);
        mImageViewUp = findViewById(R.id.textureView);
        mImageViewDown = findViewById(R.id.textureView3);
        mOn.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                if (myCameras[CAMERA1] != null) {//  
                    if (!myCameras[CAMERA1].isOpen()) myCameras[CAMERA1].openCamera();
                }
            }
        });
        mOff.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
            }
        });
        mCameraManager = (CameraManager) getSystemService(Context.CAMERA_SERVICE);
        try {
            //     
            myCameras = new CameraService[mCameraManager.getCameraIdList().length];
            for (String cameraID : mCameraManager.getCameraIdList()) {
                Log.i(LOG_TAG, "cameraID: " + cameraID);
                int id = Integer.parseInt(cameraID);
                //    
                myCameras[id] = new CameraService(mCameraManager, cameraID);
            }
        } catch (CameraAccessException e) {
            Log.e(LOG_TAG, e.getMessage());
            e.printStackTrace();
        }
    }
    public class CameraService {
        private String mCameraID;
        private CameraDevice mCameraDevice = null;
        private CameraCaptureSession mSession;
        private CaptureRequest.Builder mPreviewBuilder;
        public CameraService(CameraManager cameraManager, String cameraID) {
            mCameraManager = cameraManager;
            mCameraID = cameraID;
        }
        private CameraDevice.StateCallback mCameraCallback = new CameraDevice.StateCallback() {
            @Override
            public void onOpened(CameraDevice camera) {
                mCameraDevice = camera;
                Log.i(LOG_TAG, "Open camera  with id:" + mCameraDevice.getId());
                startCameraPreviewSession();
            }
            @Override
            public void onDisconnected(CameraDevice camera) {
                mCameraDevice.close();
                Log.i(LOG_TAG, "disconnect camera  with id:" + mCameraDevice.getId());
                mCameraDevice = null;
            }
            @Override
            public void onError(CameraDevice camera, int error) {
                Log.i(LOG_TAG, "error! camera id:" + camera.getId() + " error:" + error);
            }
        };
        private void startCameraPreviewSession() {
            SurfaceTexture texture = mImageViewUp.getSurfaceTexture();
            texture.setDefaultBufferSize(1280, 1024);
            surface1 = new Surface(texture);
            SurfaceTexture texture2 = mImageViewDown.getSurfaceTexture();
            surface2 = new Surface(texture2);
            texture2.setDefaultBufferSize(1280, 1024);
            try {
                mPreviewBuilder = mCameraDevice.createCaptureRequest(CameraDevice.TEMPLATE_RECORD);
                mPreviewBuilder.addTarget(surface1);
                mPreviewBuilder.addTarget(surface2);
                mCameraDevice.createCaptureSession(Arrays.asList(surface1,surface2),
                        new CameraCaptureSession.StateCallback() {
                            @Override
                            public void onConfigured(CameraCaptureSession session) {
                                mSession = session;

                                try {
                                    mSession.setRepeatingRequest(mPreviewBuilder.build(), null, mBackgroundHandler);
                                } catch (CameraAccessException e) {
                                    e.printStackTrace();
                                }
                            }
                            @Override
                            public void onConfigureFailed(CameraCaptureSession session) {
                            }
                        }, mBackgroundHandler);
            } catch (CameraAccessException e) {
                e.printStackTrace();
            }
        }
        public boolean isOpen() {
            if (mCameraDevice == null) {
                return false;
            } else {
                return true;
            }
        }
        public void openCamera() {
            try {
                if (checkSelfPermission(Manifest.permission.CAMERA) == PackageManager.PERMISSION_GRANTED) {
                    mCameraManager.openCamera(mCameraID, mCameraCallback, mBackgroundHandler);
                }
            } catch (CameraAccessException e) {
                Log.i(LOG_TAG, e.getMessage());
            }
        }
        public void closeCamera() {
            if (mCameraDevice != null) {
                mCameraDevice.close();
                mCameraDevice = null;
            }
        }
    }
    @Override
    public void onPause() {
        if (myCameras[CAMERA1].isOpen()) {
            myCameras[CAMERA1].closeCamera();
        }
        stopBackgroundThread();
        super.onPause();
    }
    @Override
    public void onResume() {
        super.onResume();
        startBackgroundThread();
    }
}

हां, और मत भूलना

घोषणापत्र

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="com.example.twovideosurfaces">
    <uses-permission android:name="android.permission.CAMERA" />
    <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />
    <uses-permission android:name="android.permission.INTERNET"/>
    <application
        android:allowBackup="true"
        android:icon="@mipmap/ic_launcher"
        android:label="@string/app_name"
        android:roundIcon="@mipmap/ic_launcher_round"
        android:supportsRtl="true"
        android:theme="@style/Theme.AppCompat.NoActionBar"
        >
        <activity android:name=".MainActivity">
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />
                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>
    </application>
</manifest>

अब हम स्मार्टफोन को वीआर हेडसेट में धकेलते हैं और घर के चारों ओर चलते हैं, प्रत्येक आँख के लिए 1280 x 1024 के रिज़ॉल्यूशन के साथ साइबरबाग के दर्शन का आनंद लेते हैं। बेशक, दृष्टि की गहराई के नुकसान के साथ, अजीब, लेकिन अभी भी शांत हैं। केवल एक चीज यह है कि यह थोड़ा गहरा दिखता है, लेकिन इसका कारण यह है कि फ्रंट ट्रांसलूसेंट हेडसेट पैनल हस्तक्षेप करता है। इसलिए, स्मार्टफोन के कैमरे के सामने उसमें एक छेद बनाना आवश्यक है। लेकिन फिर से, सबसे बजटीय वीआर मॉडल पर, ऐसा पैनल भी बिल्कुल मौजूद नहीं हो सकता है, और यह संभावना है कि आपको मैनुअल श्रम के साथ खुद को अपवित्र नहीं करना पड़ेगा।

अब जो कुछ बचा है वह Google कैमरा API को समझाने के लिए है कि हमारे पास पूर्ण अंधेरा है, और नाइट विजन मोड का उपयोग करना अच्छा होगा, और इसके साथ-साथ इन सभी रॉ, एचडीआर-स्टैकिंग और ~~तंत्रिका नेटवर्क द्वारा दृश्य मान्यता~~ ।

ऐसा करने के लिए, बस सत्र में लिखें:

mPreviewBuilder.set(CaptureRequest.CONTROL_SCENE_MODE,
                                            CaptureRequest.CONTROL_SCENE_MODE_NIGHT);

और अधिकतम तक एक्सपोज़र और फ़ोटोग्राफ़ी को अनसुना कर दिया

 mPreviewBuilder.set(CaptureRequest.CONTROL_AE_MODE,
        CaptureRequest.CONTROL_AE_MODE_OFF);
mPreviewBuilder.set(CaptureRequest.SENSOR_EXPOSURE_TIME,Long.valueOf("100000000"));
 mPreviewBuilder.set(CaptureRequest.SENSOR_SENSITIVITY, 30000);

ओह, मैं अंधा हूँ!

यह वही है जो बिल्ली को देखने के लिए निकलता है जब उसे बेडरूम से बाहर निकाल दिया जाता है, जहां वह लोगों को लिविंग रूम में सेक्स करने से रोकता है।

लेकिन निश्चित रूप से, यह गणना और पैरामीटर है (और एपीआई में उनमें से बहुत सारे हैं, और यहां सिर्फ एक युगल हैं) आपको बाद में इसे अनुभवजन्य रूप से ट्विक करने की आवश्यकता है।

अब हम केवल रात का इंतजार कर सकते हैं। चांदनी नहीं, ज़ाहिर है, टैगा में घने बादल के साथ, लेकिन यादृच्छिक उड़ान फोटॉनों के साथ एक साधारण ऐसी रात। और यहाँ क्या होने जा रहा है ...

हालाँकि ऐसा लगता है कि सामान्य शूटिंग के साथ, लगभग कुछ भी दिखाई नहीं दे रहा है।

लेकिन आधुनिक कैमरे अद्भुत काम करते हैं और अभी भी एक काली बिल्ली पाते हैं ...

अब आप रात में चल सकते हैं, क्योंकि दिन के दौरान आप संगरोध के कारण नहीं कर सकते। सिद्धांत रूप में, यह रात में भी असंभव है, लेकिन जो आपको देखेगा, रात के अंधेरे में उनके सिर पर वीआर हेडसेट के साथ घूरते हुए ...

चकाचौंध दृष्टि का चश्मा। मेकर पार्ट 5 फ्लैश से एंड्रॉइड कैमरा 2 एपीआई

More articles: