android - for - camera apps 2018




पूर्ण स्क्रीन में कैमरा डिस्प्ले/पूर्वावलोकन पहलू अनुपात को बनाए नहीं रखता है-स्क्रीन पर फिट करने के लिए छवि को खींचा जाता है (2)

मैंने पूर्ण स्क्रीन में कैमरा पूर्वावलोकन प्रदर्शित करने के लिए एक छोटा सा एप्लीकेशन विकसित किया है। मैं इसके लिए कैमरा एपीआई का उपयोग कर रहा हूँ।

यह गतिविधि लेआउट है:

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
              android:orientation="vertical"
              android:layout_width="match_parent"
              android:layout_height="match_parent">

    <!-- This is the container for the camera preview screen -->
    <FrameLayout android:id="@+id/camera_preview"
                 android:layout_width="wrap_content"
                 android:layout_height="wrap_content"/>
</LinearLayout>

जब डिवाइस पोर्ट्रेट में होता है, तो डिवाइस स्क्रीन की ऊंचाई से मेल खाने के लिए डिस्प्ले को लंबवत रूप से स्केल किया जाता है - इसलिए पहलू अनुपात देशी कैमरे से एक जैसा नहीं होता है। ये 2 छवियां हैं जो बताती हैं कि मैं क्या कह रहा हूं:

पहली छवि देशी कैमरा डिवाइस के साथ बनाई गई है। दूसरी छवि मेरे ऐप के साथ बनाई गई है, कैमरे के साथ पूर्ण स्क्रीन में - छवि को स्क्रीन पर फिट करने के लिए खींचा गया है।

मुझे पूर्ण पूर्वावलोकन होने के लिए कैमरा पूर्वावलोकन की आवश्यकता है, भले ही समर्थित getSupportedPreviewSizes() द्वारा दिए गए पूर्वावलोकन आकार की परवाह किए बिना पूर्वावलोकन getSupportedPreviewSizes() mehod और विरूपण के बिना। क्या इसको मदद देने का कोई तरीका है? कैमरा पूर्वावलोकन पूर्ण स्क्रीन में होने पर उचित पहलू अनुपात को बनाए रखने का कोई तरीका है? मुझे उम्मीद है कि यह ओएस द्वारा स्वचालित रूप से किया जाएगा - पक्ष अनुपात को बनाए रखने के दौरान अनुरोधित संकल्प से मेल खाने के लिए छवि को क्रॉप करना, लेकिन ऐसा नहीं होता है।

मैंने प्रदर्शन से अधिक SurfaceView बनाने की कोशिश की है (इस प्रश्न के बाद: डिस्प्ले से बड़े सतह दृश्य में कैमरा पूर्वावलोकन को फ़िट करना ), लेकिन मेरे मामले में ठीक नहीं है क्योंकि मैं स्नैपशॉट्स (6 फ्रेम / सेकेंड) कैप्चर कर रहा हूं और वे स्क्रीन पर उपयोगकर्ता को नहीं देखते हैं (फ्रेम में सभी कैमरा पूर्वावलोकन होते हैं, भले ही यह स्क्रीन पर दिखाई न दे)।

मैंने यहां पोस्ट किया है: https://www.dropbox.com/s/3d52xt8kazynsae/CameraFullScreen.7z?v=0mcn मैंने जो पूरी परियोजना बनाई है।

कोई विचार / समाधान मेरे लिए महत्वपूर्ण से अधिक है। बहुत बहुत धन्यवाद।

================================================== ======================

Ss1271 उत्तर के कारण अद्यतन करें:

मैं सैमसंग गैलेक्सी ऐस II के लिए ऊपर लिखे गए कुछ संकल्पों का विश्लेषण करूंगा।

I. स्क्रीन रेज़ोल्यूशन : 480x800 - पहलू अनुपात 3: 5 = 0,6

द्वितीय। getSupportedPreviewSizes - मुझे लगभग यकीन है कि ये मान बैक कैमरा से हैं। इन प्रस्तावों के लिए पहलू अनुपात नीचे दिए गए हैं:

   2560x1920   - 0,75

   2560x1536   - 0,60

   2048x1536   - 0,75

   2048x1232   - 0,60

   960x720     - 0,75

   640x480     - 0,75

इसलिए, आपकी विधि 2560x1536 या 2048x1232 से संबंधित Size लौटाएगी - इन्हें स्क्रीन रिज़ॉल्यूशन के समान पहलू अनुपात और इन मानों का उपयोग करने से चित्र विकृत नहीं होगा। मेरे लिए समस्या यह है कि मैं 6 बड़े फ्रेम / सेकेंड पर कब्जा करने के बाद से इतने बड़े संकल्पों का उपयोग नहीं कर सकता हूं और इन्हें निचले रिज़ॉल्यूशन पर सहेजने की जरूरत है।

मैं सैमसंग एस 2 डिवाइस से कुछ परिणाम नीचे पेश करूंगा:

I. स्क्रीन रेज़ोल्यूशन : 480 x 800 - पहलू अनुपात 3: 5 = 0,6

द्वितीय। पृष्ठ कैमरा
ए)। getSupportedPreviewSizes :

800 / 480   - 480/800 = 0,60
800 / 450   - 450/800 = 0,56
720 / 480   - 0,66 
640 / 480   - 0,75
352 / 288   - 0,81
320 / 240   - 0,75
176 / 144   - 0,81

ख)। मूल कैमरा संकल्प:

3264 / 2448  - 0,75  - not full screen
3264 / 1968  - 0,60  - FULL SCREEN (since has the same aspect ratio as device screen)
2048 / 1536  - 0,75  - not full screen
2048 / 1232  - 0,60  - FULL SCREEN (same aspect ratio as device screen)
800 / 480    - 0,60  - FULL SCREEN (same aspect ratio as device screen)
640 / 480    - 0, 75 - not full screen

तृतीय। सामने का कैमरा
ए)। getSupportedPreviewSizes :

640 / 480   - 0,75
352 / 288   - 0,81
320 / 240   - 0,75
176 / 144   - 0,81

ख)। मूल कैमरा पूर्ण स्क्रीन में नहीं है और मैं एक संकल्प का चयन नहीं कर सकता - विकल्प अक्षम है।

एस 2 के लिए, बैक कैमरा, मुझे आश्चर्य है कि क्यों getSupportedPreviewSizes() विधि उसी संकल्प को वापस नहीं करती है क्योंकि देशी कैमरा करता है या देशी कैमरे द्वारा प्रदर्शित किए गए चित्र चित्र आकार होते हैं? मुझे आश्चर्य है कि मेरे पास getSupportedPreviewSizes() 9 68, getSupportedPreviewSizes() जैसे विकल्प नहीं हैं, जो समर्थित getSupportedPreviewSizes() विधि? :


मुझे कैमरा 2 एपीआई में एक ही समस्या का सामना करना पड़ रहा था, मैंने इस मुद्दे को हल करने के लिए पूर्वावलोकन आकार और डिवाइस पहलू अनुपात का उपयोग किया है । आप अपने कैमरा एपीआई के साथ भी ऐसा ही कर सकते हैं।


संक्षेप में, आप पूर्ण स्क्रीन में कैमरा पूर्वावलोकन कर सकते हैं, हालांकि आपको अपने द्वारा समर्थित पूर्वावलोकन आकारों के बीच उचित आकारों को ढूंढना होगा, केवल तभी जब एक अनुकूलित कैमरा पूर्वावलोकन आप चाहते हैं।

एंड्रॉइड डेवलपर्स - कैमरा के अनुसार, आपके प्रश्न के लिए

यदि आप अपने कैमरे के पूर्वावलोकन के लिए एक विशिष्ट आकार सेट करना चाहते हैं, तो इसे ऊपर की टिप्पणियों में उल्लिखित surfaceChanged() विधि में सेट करें। पूर्वावलोकन आकार सेट करते समय, आपको getSupportedPreviewSizes() से मानों का उपयोग करना होगाsetPreviewSize() विधि में मनमानी मान सेट न करें

ऐसा लगता है कि आप प्राप्त आकार को मैन्युअल रूप से पास नहीं कर सकते हैं जो आप प्राप्त किए गए आकार के अलावा अन्य समर्थित getSupportedPreviewSizes() आकार getSupportedPreviewSizes() । अपने फोन कैमरे द्वारा समर्थित आकारों की नज़दीकी जांच के साथ, आपको लगता है कि समर्थित आकारों का अनुपात आपकी स्क्रीन के अनुपात के समान नहीं हो सकता है।

उदाहरण के लिए, सैमसंग गैलेक्सी ऐस II में 480x800 रिज़ॉल्यूशन स्क्रीन है, जो getSupportedPreviewSizes() से लौटाया गया Size पढ़कर, इसका कैमरा समर्थन करता है:

2560x1920

2560x1536

2048x1536

2048x1232

960x720

640x480

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

एक उचित पूर्वावलोकन आकार खोजने का कार्यान्वयन जटिल सामान नहीं है। ऐसा करने के लिए एक आम विधि इस तरह कुछ होगा:

    /**
     * Calculate the optimal size of camera preview
     * @param sizes
     * @param w
     * @param h
     * @return
     */
    private Size getOptimalSize(List<Size> sizes, int w, int h) {

        final double ASPECT_TOLERANCE = 0.2;        
        double targetRatio = (double) w / h;         
        if (sizes == null)             
            return null;          
        Size optimalSize = null;         
        double minDiff = Double.MAX_VALUE;          
        int targetHeight = h;          
        // Try to find an size match aspect ratio and size         
        for (Size size : sizes) 
        {             
//          Log.d("CameraActivity", "Checking size " + size.width + "w " + size.height + "h");            
            double ratio = (double) size.width / size.height;            
            if (Math.abs(ratio - targetRatio) > ASPECT_TOLERANCE)                
                continue;             
            if (Math.abs(size.height - targetHeight) < minDiff) 
            {                 
                optimalSize = size;                 
                minDiff = Math.abs(size.height - targetHeight);             
            }         
        }          
        // Cannot find the one match the aspect ratio, ignore the requirement     

        if (optimalSize == null)
        {
            minDiff = Double.MAX_VALUE;             
            for (Size size : sizes) {
                if (Math.abs(size.height - targetHeight) < minDiff)
                {
                    optimalSize = size;
                    minDiff = Math.abs(size.height - targetHeight); 
                }
            }
        }

        SharedPreferences previewSizePref;
        if (cameraId == Camera.CameraInfo.CAMERA_FACING_BACK) {
            previewSizePref = getSharedPreferences("PREVIEW_PREF",MODE_PRIVATE);
        } else {
            previewSizePref = getSharedPreferences("FRONT_PREVIEW_PREF",MODE_PRIVATE);
        }

        SharedPreferences.Editor prefEditor = previewSizePref.edit();
        prefEditor.putInt("width", optimalSize.width);
        prefEditor.putInt("height", optimalSize.height);

        prefEditor.commit();

//      Log.d("CameraActivity", "Using size: " + optimalSize.width + "w " + optimalSize.height + "h");            
        return optimalSize;     
    }

और आप उपयुक्त कैमरा आकार (आउटपुट चित्र आकार) को खोजने के लिए भी ऐसा ही कर सकते हैं।

नोट: मुझे इंटरनेट से उपरोक्त कोड का मूल संस्करण मिला और मैंने अपने उद्देश्य के लिए कुछ संशोधन / अनुकूलन किया।

अगर यह आपके लिए काम करता है तो कृपया मुझे बताएं।