android - एंड्रॉइड में कैमरा अभिविन्यास मुद्दा




camera android-intent (10)

इस तरह से प्रयास करें: स्थैतिक उरी image_uri; स्थैतिक बिटमैप take_image = शून्य;

            image_uri=fileUri; // file where image has been saved

      taken_image=BitmapFactory.decodeFile(image_uri.getPath());
      try
        {
            ExifInterface exif = new ExifInterface(image_uri.getPath()); 

            int orientation = exif.getAttributeInt(ExifInterface.TAG_ORIENTATION, ExifInterface.ORIENTATION_NORMAL);


            switch(orientation) {
                case ExifInterface.ORIENTATION_ROTATE_90:
                    taken_image=decodeScaledBitmapFromSdCard(image_uri.getPath(), 200, 200);
                    RotateBitmap(taken_image, 90);
                    break;
                case ExifInterface.ORIENTATION_ROTATE_180:
                    taken_image=decodeScaledBitmapFromSdCard(image_uri.getPath(), 200, 200);
                    RotateBitmap(taken_image, 180);

                    break;
                case ExifInterface.ORIENTATION_ROTATE_270:
                    taken_image=decodeScaledBitmapFromSdCard(image_uri.getPath(), 200, 200);
                    RotateBitmap(taken_image, 270);

                    break;
                case ExifInterface.ORIENTATION_NORMAL:
                    taken_image=decodeScaledBitmapFromSdCard(image_uri.getPath(), 200, 200);
                    RotateBitmap(taken_image, 0);

                    break;
            }

        }
        catch (OutOfMemoryError e)
        {
            Toast.makeText(getActivity(),e+"\"memory exception occured\"",Toast.LENGTH_LONG).show();


        }



public Bitmap RotateBitmap(Bitmap source, float angle) {
      Matrix matrix = new Matrix();
      matrix.postRotate(angle);

      round_Image = source;
      round_Image = Bitmap.createBitmap(source, 0, 0, source.getWidth(),   source.getHeight(), matrix, true);


  return Bitmap.createBitmap(source, 0, 0, source.getWidth(), source.getHeight(), matrix, true);

}

मैं एक ऐसा एप्लिकेशन बना रहा हूं जो चित्र लेने के लिए कैमरे का उपयोग करता है। ऐसा करने के लिए मेरा स्रोत कोड यहां दिया गया है:

        File file = new File(Environment.getExternalStorageDirectory(),
            imageFileName);
    imageFilePath = file.getPath();
    Intent intent = new Intent("android.media.action.IMAGE_CAPTURE");
    //Intent intent = new Intent(MediaStore.ACTION_IMAGE_CAPTURE);
    intent.putExtra(MediaStore.EXTRA_OUTPUT, Uri.fromFile(file));
    startActivityForResult(intent, ACTIVITY_NATIVE_CAMERA_AQUIRE);

onActivityResult() विधि पर, मैं छवि को पिकअप करने के लिए BitmapFactory.decodeStream() का उपयोग करता BitmapFactory.decodeStream()

जब मैं नेक्सस पर अपना एप्लिकेशन चलाता हूं, तो यह अच्छी तरह से चलता है। लेकिन जब मैं सैमसंग गैलेक्सी एस या एचटीसी प्रेरणा 4 जी पर चलता हूं, तो छवि की दिशा सही नहीं होती है।

  • पोर्ट्रेट मोड के साथ कैप्चर करें, वास्तविक छवि (एसडी कार्ड पर सहेजें) हमेशा 90 डिग्री घुमाती है।

शॉट के बाद छवि पूर्वावलोकन --------- एसडी कार्ड पर वास्तविक छवि

  • लैंडस्केप मोड के साथ कैप्चर करें, सभी चीजें अच्छी हैं।

शॉट के बाद छवि पूर्वावलोकन --------- एसडी कार्ड पर वास्तविक छवि


एक और विकल्प परिणाम स्क्रीन में बिटमैप को घुमाने के लिए है:

ImageView img=(ImageView)findViewById(R.id.ImageView01);
Bitmap bmp = BitmapFactory.decodeResource(getResources(), R.drawable.refresh);
// Getting width & height of the given image.
int w = bmp.getWidth();
int h = bmp.getHeight();
// Setting post rotate to 90
Matrix mtx = new Matrix();
mtx.postRotate(90);
// Rotating Bitmap
Bitmap rotatedBMP = Bitmap.createBitmap(bmp, 0, 0, w, h, mtx, true);
BitmapDrawable bmd = new BitmapDrawable(rotatedBMP);

img.setImageDrawable(bmd);

दो चीजें आवश्यक हैं:

  1. कैमरा पूर्वावलोकन को आपके घूर्णन के समान ही चाहिए। इसे camera.setDisplayOrientation(result); द्वारा सेट करें camera.setDisplayOrientation(result);

  2. अपने कैमरे के पूर्वावलोकन के रूप में कैप्चर की गई तस्वीर को सहेजें। Camera.Parameters माध्यम से Camera.ParametersCamera.Parameters

    int mRotation = getCameraDisplayOrientation();
    
    Camera.Parameters parameters = camera.getParameters();
    
    parameters.setRotation(mRotation); //set rotation to save the picture
    
    camera.setDisplayOrientation(result); //set the rotation for preview camera
    
    camera.setParameters(parameters);
    

उम्मीद है की वो मदद करदे।


फोटो के एक्फिफ़ डेटा की जांच नहीं कर रहे हैं। ग्लाइड के साथ आसान जाओ।

Google ने हमें एंड्रॉइड के लिए एक छवि लोडर लाइब्रेरी पेश की जिसे ग्लैड नामक बंपटेक द्वारा विकसित किया गया था, जो Google द्वारा अनुशंसित लाइब्रेरी के रूप में है। इसका उपयोग Google I / O 2014 आधिकारिक एप्लिकेशन सहित अब तक कई Google ओपन सोर्स प्रोजेक्ट्स में किया गया है।

पूर्व: ग्लाइड.with (संदर्भ) .load (uri) .into (imageview);

अधिक के लिए: https://github.com/bumptech/glide


मुझे बस एक ही समस्या का सामना करना पड़ा, और अभिविन्यास को सही करने के लिए इसका इस्तेमाल किया गया:

public void fixOrientation() {
    if (mBitmap.getWidth() > mBitmap.getHeight()) {
        Matrix matrix = new Matrix();
        matrix.postRotate(90);
        mBitmap = Bitmap.createBitmap(mBitmap , 0, 0, mBitmap.getWidth(), mBitmap.getHeight(), matrix, true);
    }
}

यदि बिटमैप की चौड़ाई ऊंचाई से अधिक है, तो लौटाई गई छवि परिदृश्य में है, इसलिए मैं इसे 90 डिग्री घुमाता हूं।

उम्मीद है कि यह इस मुद्दे के साथ किसी और की मदद करता है।


मेरे पास कुछ डिवाइस के लिए भी यही समस्या है:

private void rotateImage(final String path) {

    Bitmap scaledBitmap = Bitmap.createScaledBitmap(Conasants.bm1, 1000,
            700, true);
    Bitmap rotatedBitmap = null;
    try {
        ExifInterface ei = new ExifInterface(path);
        int orientation = ei.getAttributeInt(ExifInterface.TAG_ORIENTATION,
                ExifInterface.ORIENTATION_NORMAL);
        Matrix matrix = new Matrix();
        switch (orientation) {
        case ExifInterface.ORIENTATION_ROTATE_90:
            matrix.postRotate(90);
            rotatedBitmap = Bitmap.createBitmap(scaledBitmap, 0, 0,
                    scaledBitmap.getWidth(), scaledBitmap.getHeight(),
                    matrix, true);
            break;
        case ExifInterface.ORIENTATION_ROTATE_180:
            matrix.postRotate(180);
            rotatedBitmap = Bitmap.createBitmap(scaledBitmap, 0, 0,
                    scaledBitmap.getWidth(), scaledBitmap.getHeight(),
                    matrix, true);
            break;
        case ExifInterface.ORIENTATION_ROTATE_270:
            matrix.postRotate(270);
            rotatedBitmap = Bitmap.createBitmap(scaledBitmap, 0, 0,
                    scaledBitmap.getWidth(), scaledBitmap.getHeight(),
                    matrix, true);
            break;
        default:
            rotatedBitmap = Bitmap.createBitmap(scaledBitmap, 0, 0,
                    scaledBitmap.getWidth(), scaledBitmap.getHeight(),
                    matrix, true);
            break;
        }
    } catch (Throwable e) {
        e.printStackTrace();
    }
    cropImage.setImageBitmap(rotatedBitmap);
    rotatedBitmap = null;
    Conasants.bm1 = null;
}

सतह में इसे आज़माएं चेंजबैक कॉलबैक:

Camera.Parameters parameters=mCamera.getParameters();
if(this.getResources().getConfiguration().orientation == ActivityInfo.SCREEN_ORIENTATION_PORTRAIT){
    parameters.setRotation(90);
}else{
    parameters.setRotation(0);
}
mCamera.setParameters(parameters);

पिकासो और ग्लाइड लाइब्रेरी का उपयोग करके दो लाइन समाधान

छवि रोटेशन समस्या के लिए बहुत सारे समाधानों के साथ बहुत समय व्यतीत करने के बाद मुझे अंततः दो सरल समाधान मिल गए। हमें कोई अतिरिक्त काम करने की ज़रूरत नहीं है। पिकासो और ग्लाइड आपके ऐप में छवियों को संभालने के लिए एक बहुत ही शक्तिशाली लाइब्रेरी है। यह छवि EXIF ​​डेटा पढ़ेगा और छवियों को ऑटो-घुमाएगा।

ग्लाइड लाइब्रेरी का उपयोग https://github.com/bumptech/glide

Glide.with(this).load("http url or sdcard url").into(imgageView);

पिकासो लाइब्रेरी का उपयोग https://github.com/square/picasso

Picasso.with(context).load("http url or sdcard url").into(imageView);

    public static  int mOrientation =  1;

    OrientationEventListener myOrientationEventListener;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        // TODO Auto-generated method stub
        super.onCreate(savedInstanceState);
        setContentView(R.layout.takephoto);

        setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT);


        myOrientationEventListener
        = new OrientationEventListener(getApplicationContext()) {

            @Override
            public void onOrientationChanged(int o) {
                // TODO Auto-generated method stub
                if(!isTablet(getApplicationContext()))
                {
                    if(o<=285 && o>=80)
                        mOrientation = 2;
                    else
                        mOrientation = 1;
                }
                else
                {
                    if(o<=285 && o>=80)
                        mOrientation = 1;
                    else
                        mOrientation = 2;
                }

            }
        };

        myOrientationEventListener.enable();

    }



    public static boolean isTablet(Context context) {
        return (context.getResources().getConfiguration().screenLayout
                & Configuration.SCREENLAYOUT_SIZE_MASK)
                >= Configuration.SCREENLAYOUT_SIZE_LARGE;
    }

}

मुझे आशा है कि इससे मदद मिलेगी.धन्यवाद!


public void setCameraPicOrientation(){
        int rotate = 0;
        try {
            File imageFile = new File(mCurrentPhotoPath);
            ExifInterface exif = new ExifInterface(
                    imageFile.getAbsolutePath());
            int orientation = exif.getAttributeInt(
                    ExifInterface.TAG_ORIENTATION,
                    ExifInterface.ORIENTATION_NORMAL);

            switch (orientation) {
                case ExifInterface.ORIENTATION_ROTATE_270:
                    rotate = 270;
                    break;
                case ExifInterface.ORIENTATION_ROTATE_180:
                    rotate = 180;
                    break;
                case ExifInterface.ORIENTATION_ROTATE_90:
                    rotate = 90;
                    break;
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        Matrix matrix = new Matrix();
        matrix.postRotate(rotate);
        int targetW = 640;
        int targetH = 640;

        /* Get the size of the image */
        BitmapFactory.Options bmOptions = new BitmapFactory.Options();
        bmOptions.inJustDecodeBounds = true;
        BitmapFactory.decodeFile(mCurrentPhotoPath, bmOptions);
        int photoW = bmOptions.outWidth;
        int photoH = bmOptions.outHeight;

        /* Figure out which way needs to be reduced less */
        int scaleFactor = 1;
        if ((targetW > 0) || (targetH > 0)) {
            scaleFactor = Math.min(photoW/targetW, photoH/targetH);
        }

        /* Set bitmap options to scale the image decode target */
        bmOptions.inJustDecodeBounds = false;
        bmOptions.inSampleSize = scaleFactor;
        bmOptions.inPurgeable = true;

        /* Decode the JPEG file into a Bitmap */
        Bitmap bitmap = BitmapFactory.decodeFile(mCurrentPhotoPath, bmOptions);
        bitmap= Bitmap.createBitmap(bitmap , 0, 0, bitmap.getWidth(), bitmap.getHeight(), matrix, true);
            /* Associate the Bitmap to the ImageView */
      imageView.setImageBitmap(bitmap);
    }

उम्मीद है कि यह मदद करेगा !! धन्यवाद





capture