갤러리에서 이미지 패스를 통해 가져 오는 동안 이미지 크기를 줄이는 방법

Question

카메라에서 이미지를 찍고 싶고 갤러리에서 가져간 부분도 가져 가고 싶습니다. 하나의 작업에서 다른 이미지 경로로 이미지를 가져갈 때 네 번째 이미지를 가져 오는 중 오류가 발생하여 메모리에서 오류가 발생하므로 갤러리에서 이미지를 가져오고 갤러리에서 이미지를 가져 와서 압축해야 메모리가 없어야합니다 오류 바이트 할당.

감사합니다.

여기 내 코드는 사람이 때문에 이미지 크기의 발생이

imageview1=(ImageView) findViewById(R.id.image1); 
    imageview2=(ImageView) findViewById(R.id.image2); 
    imageview3=(ImageView) findViewById(R.id.image3); 
    imageview4=(ImageView) findViewById(R.id.image4); 


    Bitmap b = (Bitmap) getIntent().getParcelableExtra("data") ; 

    SharedPreferences preferences = PreferenceManager.getDefaultSharedPreferences(this); 
    locationname = preferences.getString("Location", "Location"); 

    SharedPreferences preferences1 = PreferenceManager.getDefaultSharedPreferences(this); 
    categoryname = preferences1.getString("categoryname", "categoryname"); 

    SharedPreferences imagepath1 = PreferenceManager.getDefaultSharedPreferences(this); 
    selectedImagePath1 = imagepath1.getString("picturePath1", "picturePath1"); 


    SharedPreferences imagepath2 = PreferenceManager.getDefaultSharedPreferences(this); 
    selectedImagePath2 = imagepath2.getString("picturePath2", "picturePath2"); 

    SharedPreferences imagepath3 = PreferenceManager.getDefaultSharedPreferences(this); 
    selectedImagePath3 = imagepath3.getString("picturePath3", "picturePath3"); 

    SharedPreferences imagepath4 = PreferenceManager.getDefaultSharedPreferences(this); 
    selectedImagePath4 = imagepath4.getString("picturePath4", "picturePath4"); 


    Bitmap thumbnail1 = (BitmapFactory.decodeFile(selectedImagePath1)); 
    ByteArrayOutputStream stream = new ByteArrayOutputStream(); 
    thumbnail1.compress(Bitmap.CompressFormat.JPEG, 90, stream); 

    Bitmap thumbnail2 = (BitmapFactory.decodeFile(selectedImagePath2)); 
    ByteArrayOutputStream stream1 = new ByteArrayOutputStream(); 
    thumbnail2.compress(Bitmap.CompressFormat.JPEG, 90, stream1); 

    Bitmap thumbnail3 = (BitmapFactory.decodeFile(selectedImagePath3)); 
    ByteArrayOutputStream stream2 = new ByteArrayOutputStream(); 
    thumbnail2.compress(Bitmap.CompressFormat.JPEG, 90, stream2); 

    Bitmap thumbnail4 = (BitmapFactory.decodeFile(selectedImagePath4)); 
    ByteArrayOutputStream stream3 = new ByteArrayOutputStream(); 
    thumbnail4.compress(Bitmap.CompressFormat.JPEG, 90, stream3); 


    imageview1.setImageBitmap(thumbnail1); 
    thumbnail1.recycle(); 
    imageview2.setImageBitmap(thumbnail2); 
    imageview3.setImageBitmap(thumbnail3); 
    imageview4.setImageBitmap(thumbnail4); 

Answer 1

에 도움이 될 수 있습니다. 이미지 크기를 조정하거나 압축해야합니다. 아래 코드가 도움이 될 것입니다. 코드 아래

public static Bitmap loadResizedBitmap(String filename, int width, int height, boolean exact) { 
    Bitmap bitmap = null; 
    BitmapFactory.Options options = new BitmapFactory.Options(); 
    options.inJustDecodeBounds = true; 
    BitmapFactory.decodeFile(filename, options); 
    if (options.outHeight > 0 && options.outWidth > 0) { 
     options.inJustDecodeBounds = false; 
     options.inSampleSize = 2; 
     while ( options.outWidth/options.inSampleSize > width 
       && options.outHeight/options.inSampleSize > height) { 
      options.inSampleSize++; 
     } 
     options.inSampleSize--; 

     bitmap = BitmapFactory.decodeFile(filename, options); 
     if (bitmap != null && exact) { 
      bitmap = Bitmap.createScaledBitmap(bitmap, width, height, false); 
     } 
    } 
    return bitmap; 
} 

또는

public static int calculateInSampleSize(
      BitmapFactory.Options options, int reqWidth, int reqHeight) { 
    // Raw height and width of image 
    final int height = options.outHeight; 
    final int width = options.outWidth; 
    int inSampleSize = 1; 

    if (height > reqHeight || width > reqWidth) { 

     final int halfHeight = height/2; 
     final int halfWidth = width/2; 

     // Calculate the largest inSampleSize value that is a power of 2 and keeps both 
     // height and width larger than the requested height and width. 
     while ((halfHeight/inSampleSize) > reqHeight 
       && (halfWidth/inSampleSize) > reqWidth) { 
      inSampleSize *= 2; 
     } 
    } 

    return inSampleSize; 
} 

Answer 2

보십시오 : 당신의 필요에 따라 사용 -

public String compressImage(String imageUri) { 

     String filePath = getRealPathFromURI(imageUri); 
     Bitmap scaledBitmap = null; 

     BitmapFactory.Options options = new BitmapFactory.Options(); 

//  by setting this field as true, the actual bitmap pixels are not loaded in the memory. Just the bounds are loaded. If 
//  you try the use the bitmap here, you will get null. 
     options.inJustDecodeBounds = true; 
     Bitmap bmp = BitmapFactory.decodeFile(filePath, options); 

     int actualHeight = options.outHeight; 
     int actualWidth = options.outWidth; 

//  max Height and width values of the compressed image is taken as 816x612 

     float maxHeight = 816.0f; 
     float maxWidth = 612.0f; 
     float imgRatio = actualWidth/actualHeight; 
     float maxRatio = maxWidth/maxHeight; 

//  width and height values are set maintaining the aspect ratio of the image 

     if (actualHeight > maxHeight || actualWidth > maxWidth) { 
      if (imgRatio < maxRatio) {    imgRatio = maxHeight/actualHeight;    actualWidth = (int) (imgRatio * actualWidth);    actualHeight = (int) maxHeight;    } else if (imgRatio > maxRatio) { 
       imgRatio = maxWidth/actualWidth; 
       actualHeight = (int) (imgRatio * actualHeight); 
       actualWidth = (int) maxWidth; 
      } else { 
       actualHeight = (int) maxHeight; 
       actualWidth = (int) maxWidth; 

      } 
     } 

//  setting inSampleSize value allows to load a scaled down version of the original image 

     options.inSampleSize = calculateInSampleSize(options, actualWidth, actualHeight); 

//  inJustDecodeBounds set to false to load the actual bitmap 
     options.inJustDecodeBounds = false; 

//  this options allow android to claim the bitmap memory if it runs low on memory 
     options.inPurgeable = true; 
     options.inInputShareable = true; 
     options.inTempStorage = new byte[16 * 1024]; 

     try { 
//   load the bitmap from its path 
      bmp = BitmapFactory.decodeFile(filePath, options); 
     } catch (OutOfMemoryError exception) { 
      exception.printStackTrace(); 

     } 
     try { 
      scaledBitmap = Bitmap.createBitmap(actualWidth, actualHeight,Bitmap.Config.ARGB_8888); 
     } catch (OutOfMemoryError exception) { 
      exception.printStackTrace(); 
     } 

     float ratioX = actualWidth/(float) options.outWidth; 
     float ratioY = actualHeight/(float) options.outHeight; 
     float middleX = actualWidth/2.0f; 
     float middleY = actualHeight/2.0f; 

     Matrix scaleMatrix = new Matrix(); 
     scaleMatrix.setScale(ratioX, ratioY, middleX, middleY); 

     Canvas canvas = new Canvas(scaledBitmap); 
     canvas.setMatrix(scaleMatrix); 
     canvas.drawBitmap(bmp, middleX - bmp.getWidth()/2, middleY - bmp.getHeight()/2, new Paint(Paint.FILTER_BITMAP_FLAG)); 

//  check the rotation of the image and display it properly 
     ExifInterface exif; 
     try { 
      exif = new ExifInterface(filePath); 

      int orientation = exif.getAttributeInt(
        ExifInterface.TAG_ORIENTATION, 0); 
      Log.d("EXIF", "Exif: " + orientation); 
      Matrix matrix = new Matrix(); 
      if (orientation == 6) { 
       matrix.postRotate(90); 
       Log.d("EXIF", "Exif: " + orientation); 
      } else if (orientation == 3) { 
       matrix.postRotate(180); 
       Log.d("EXIF", "Exif: " + orientation); 
      } else if (orientation == 8) { 
       matrix.postRotate(270); 
       Log.d("EXIF", "Exif: " + orientation); 
      } 
      scaledBitmap = Bitmap.createBitmap(scaledBitmap, 0, 0, 
        scaledBitmap.getWidth(), scaledBitmap.getHeight(), matrix, 
        true); 
     } catch (IOException e) { 
      e.printStackTrace(); 
     } 

     FileOutputStream out = null; 
     String filename = getFilename(); 
     try { 
      out = new FileOutputStream(filename); 

//   write the compressed bitmap at the destination specified by filename. 
      scaledBitmap.compress(Bitmap.CompressFormat.JPEG, 80, out); 

     } catch (FileNotFoundException e) { 
      e.printStackTrace(); 
     } 

     return filename; 

    } 

안드로이드에서

http://voidcanvas.com/whatsapp-like-image-compression-in-android/

Answer 3

, 메모리에로드 될 때마다 비트 맵 , 메모리 크기의 "너비 * 높이 * 4 바이트"를 얻으십시오. 그래서 작은 비트 맵을 메모리로 가져와야합니다. 이 부분을보세요. link