Jak skompresować rozmiar obrazu?

Question

Chcę przechwytywać obraz w niskiej rozdzielczości za pomocą api api aparatu Android, ale po przechwyceniu obrazu zajmie domyślną rozdzielczość aparatu urządzenia. Tak więc chcę uchwycić obraz w niskiej rozdzielczości lub małym rozmiarze w momencie przechwytywania lub jak mogę skompresować duże obraz na mały rozmiar w systemie Android? Ktoś wie, że pls mi pomo .........

Answer 1

Można utworzyć bitmapę z przechwyconego obrazu, jak poniżej:

Bitmap bitmap = Bitmap.createScaledBitmap(capturedImage, width, height, true); 

Tutaj można określić szerokość i wysokość bitmapy, które chcesz ustawić na swój ImageView. Wysokość i szerokość można ustawić zgodnie z rozdzielczością ekranu urządzenia również, programując programowo odczyty ekranu różnych urządzeń.

Answer 2

Możesz kompresować bitmapę obrazów w ten sposób.

ByteArrayOutputStream out = new ByteArrayOutputStream(); 
bitmap.compress(Bitmap.CompressFormat.PNG, 100, out); 

Tutaj 100 to jakość obrazu i można zmienić format obrazu, aby uzyskać obraz o niskiej rozdzielczości.

Answer 3

Spróbuj tego działa dobrze ze mną.

private String decodeFile(String path) { 
     String strMyImagePath = null; 
     Bitmap scaledBitmap = null; 

     try { 
      // Part 1: Decode image 
      Bitmap unscaledBitmap = ScalingUtilities.decodeFile(path, DESIREDWIDTH, DESIREDHEIGHT, ScalingLogic.FIT); 

      if (!(unscaledBitmap.getWidth() <= 800 && unscaledBitmap.getHeight() <= 800)) { 
       // Part 2: Scale image 
       scaledBitmap = ScalingUtilities.createScaledBitmap(unscaledBitmap, DESIREDWIDTH, DESIREDHEIGHT, ScalingLogic.FIT); 
      } else { 
       unscaledBitmap.recycle(); 
       return path; 
      } 

      // Store to tmp file 

      String extr = Environment.getExternalStorageDirectory().toString(); 
      File mFolder = new File(extr + "/myTmpDir"); 
      if (!mFolder.exists()) { 
       mFolder.mkdir(); 
      } 

      String s = "tmp.png"; 

      File f = new File(mFolder.getAbsolutePath(), s); 

      strMyImagePath = f.getAbsolutePath(); 
      FileOutputStream fos = null; 
      try { 
       fos = new FileOutputStream(f); 
       scaledBitmap.compress(Bitmap.CompressFormat.PNG, 70, fos); 
       fos.flush(); 
       fos.close(); 
      } catch (FileNotFoundException e) { 

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

       e.printStackTrace(); 
      } 

      scaledBitmap.recycle(); 
     } catch (Throwable e) { 
     } 

     if (strMyImagePath == null) { 
      return path; 
     } 
     return strMyImagePath; 

    } 

Klasa Utility

public class ScalingUtilities { 

    /** 
    * Utility function for decoding an image resource. The decoded bitmap will 
    * be optimized for further scaling to the requested destination dimensions 
    * and scaling logic. 
    * 
    * @param res The resources object containing the image data 
    * @param resId The resource id of the image data 
    * @param dstWidth Width of destination area 
    * @param dstHeight Height of destination area 
    * @param scalingLogic Logic to use to avoid image stretching 
    * @return Decoded bitmap 
    */ 
    public static Bitmap decodeResource(Resources res, int resId, int dstWidth, int dstHeight, 
      ScalingLogic scalingLogic) { 
     Options options = new Options(); 
     options.inJustDecodeBounds = true; 
     BitmapFactory.decodeResource(res, resId, options); 
     options.inJustDecodeBounds = false; 
     options.inSampleSize = calculateSampleSize(options.outWidth, options.outHeight, dstWidth, 
       dstHeight, scalingLogic); 
     Bitmap unscaledBitmap = BitmapFactory.decodeResource(res, resId, options); 

     return unscaledBitmap; 
    } 
    public static Bitmap decodeFile(String path, int dstWidth, int dstHeight, 
      ScalingLogic scalingLogic) { 
     Options options = new Options(); 
     options.inJustDecodeBounds = true; 
     BitmapFactory.decodeFile(path, options); 
     options.inJustDecodeBounds = false; 
     options.inSampleSize = calculateSampleSize(options.outWidth, options.outHeight, dstWidth, 
       dstHeight, scalingLogic); 
     Bitmap unscaledBitmap = BitmapFactory.decodeFile(path, options); 

     return unscaledBitmap; 
    } 

    /** 
    * Utility function for creating a scaled version of an existing bitmap 
    * 
    * @param unscaledBitmap Bitmap to scale 
    * @param dstWidth Wanted width of destination bitmap 
    * @param dstHeight Wanted height of destination bitmap 
    * @param scalingLogic Logic to use to avoid image stretching 
    * @return New scaled bitmap object 
    */ 
    public static Bitmap createScaledBitmap(Bitmap unscaledBitmap, int dstWidth, int dstHeight, 
      ScalingLogic scalingLogic) { 
     Rect srcRect = calculateSrcRect(unscaledBitmap.getWidth(), unscaledBitmap.getHeight(), 
       dstWidth, dstHeight, scalingLogic); 
     Rect dstRect = calculateDstRect(unscaledBitmap.getWidth(), unscaledBitmap.getHeight(), 
       dstWidth, dstHeight, scalingLogic); 
     Bitmap scaledBitmap = Bitmap.createBitmap(dstRect.width(), dstRect.height(), 
       Config.ARGB_8888); 
     Canvas canvas = new Canvas(scaledBitmap); 
     canvas.drawBitmap(unscaledBitmap, srcRect, dstRect, new Paint(Paint.FILTER_BITMAP_FLAG)); 

     return scaledBitmap; 
    } 

    /** 
    * ScalingLogic defines how scaling should be carried out if source and 
    * destination image has different aspect ratio. 
    * 
    * CROP: Scales the image the minimum amount while making sure that at least 
    * one of the two dimensions fit inside the requested destination area. 
    * Parts of the source image will be cropped to realize this. 
    * 
    * FIT: Scales the image the minimum amount while making sure both 
    * dimensions fit inside the requested destination area. The resulting 
    * destination dimensions might be adjusted to a smaller size than 
    * requested. 
    */ 
    public static enum ScalingLogic { 
     CROP, FIT 
    } 

    /** 
    * Calculate optimal down-sampling factor given the dimensions of a source 
    * image, the dimensions of a destination area and a scaling logic. 
    * 
    * @param srcWidth Width of source image 
    * @param srcHeight Height of source image 
    * @param dstWidth Width of destination area 
    * @param dstHeight Height of destination area 
    * @param scalingLogic Logic to use to avoid image stretching 
    * @return Optimal down scaling sample size for decoding 
    */ 
    public static int calculateSampleSize(int srcWidth, int srcHeight, int dstWidth, int dstHeight, 
      ScalingLogic scalingLogic) { 
     if (scalingLogic == ScalingLogic.FIT) { 
      final float srcAspect = (float)srcWidth/(float)srcHeight; 
      final float dstAspect = (float)dstWidth/(float)dstHeight; 

      if (srcAspect > dstAspect) { 
       return srcWidth/dstWidth; 
      } else { 
       return srcHeight/dstHeight; 
      } 
     } else { 
      final float srcAspect = (float)srcWidth/(float)srcHeight; 
      final float dstAspect = (float)dstWidth/(float)dstHeight; 

      if (srcAspect > dstAspect) { 
       return srcHeight/dstHeight; 
      } else { 
       return srcWidth/dstWidth; 
      } 
     } 
    } 

    /** 
    * Calculates source rectangle for scaling bitmap 
    * 
    * @param srcWidth Width of source image 
    * @param srcHeight Height of source image 
    * @param dstWidth Width of destination area 
    * @param dstHeight Height of destination area 
    * @param scalingLogic Logic to use to avoid image stretching 
    * @return Optimal source rectangle 
    */ 
    public static Rect calculateSrcRect(int srcWidth, int srcHeight, int dstWidth, int dstHeight, 
      ScalingLogic scalingLogic) { 
     if (scalingLogic == ScalingLogic.CROP) { 
      final float srcAspect = (float)srcWidth/(float)srcHeight; 
      final float dstAspect = (float)dstWidth/(float)dstHeight; 

      if (srcAspect > dstAspect) { 
       final int srcRectWidth = (int)(srcHeight * dstAspect); 
       final int srcRectLeft = (srcWidth - srcRectWidth)/2; 
       return new Rect(srcRectLeft, 0, srcRectLeft + srcRectWidth, srcHeight); 
      } else { 
       final int srcRectHeight = (int)(srcWidth/dstAspect); 
       final int scrRectTop = (int)(srcHeight - srcRectHeight)/2; 
       return new Rect(0, scrRectTop, srcWidth, scrRectTop + srcRectHeight); 
      } 
     } else { 
      return new Rect(0, 0, srcWidth, srcHeight); 
     } 
    } 

    /** 
    * Calculates destination rectangle for scaling bitmap 
    * 
    * @param srcWidth Width of source image 
    * @param srcHeight Height of source image 
    * @param dstWidth Width of destination area 
    * @param dstHeight Height of destination area 
    * @param scalingLogic Logic to use to avoid image stretching 
    * @return Optimal destination rectangle 
    */ 
    public static Rect calculateDstRect(int srcWidth, int srcHeight, int dstWidth, int dstHeight, 
      ScalingLogic scalingLogic) { 
     if (scalingLogic == ScalingLogic.FIT) { 
      final float srcAspect = (float)srcWidth/(float)srcHeight; 
      final float dstAspect = (float)dstWidth/(float)dstHeight; 

      if (srcAspect > dstAspect) { 
       return new Rect(0, 0, dstWidth, (int)(dstWidth/srcAspect)); 
      } else { 
       return new Rect(0, 0, (int)(dstHeight * srcAspect), dstHeight); 
      } 
     } else { 
      return new Rect(0, 0, dstWidth, dstHeight); 
     } 
    } 

} 

Answer 4

Wystarczy spróbować ten

byte[] data = null; 
    ByteArrayOutputStream baos = new ByteArrayOutputStream(); 
    bi.compress(Bitmap.CompressFormat.JPEG, 100, baos); 
    data = baos.toByteArray(); 

Answer 5

@Override 
public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) { 
    View view = inflater.inflate(R.layout.activity_home_fragment_month, container, false); 

    GridView gridView = (GridView) view.findViewById(R.id.activity_gridview_gv); 
    SwingBottomInAnimationAdapter swingBottomInAnimationAdapter = 
      new SwingBottomInAnimationAdapter(new GridViewAdapter(getActivity().getApplicationContext())); 

    swingBottomInAnimationAdapter.setAbsListView(gridView); 
    swingBottomInAnimationAdapter.setInitialDelayMillis(300); 
    gridView.setAdapter(swingBottomInAnimationAdapter); 

    return view; 
} 

public class GridViewAdapter rozciąga BaseAdapter {

private Context mContext; 

    File folder = new File(Environment.getExternalStorageDirectory().getPath()+"/Test/"); 

    String[] allFiles = folder.list(); 

    public GridViewAdapter(Context c){ 
     mContext = c; 
    }   

    public int getCount() { 
     return allFiles.length; 
    } 

    public Object getItem(int position) { 
     return position; 
    } 

    public long getItemId(int position) { 
     return position; 
    } 

    public View getView(int position, View convertView, ViewGroup parent) { 

     ImageView imageView = new ImageView(mContext); 

     if (convertView != null) { 
      imageView = (ImageView) convertView; 
     }else { 
      imageView = new ImageView(mContext); 
      imageView.setAdjustViewBounds(false); 
      imageView.setScaleType(ImageView.ScaleType.CENTER_CROP); 
     }   

     // Decode the filepath with BitmapFactory followed by the position 
     Bitmap bmp = BitmapFactory.decodeFile(folder + "/"+ allFiles[position]); 
     //BitmapDrawable drawableImage = new BitmapDrawable(bmp); 

     // Set the decoded bitmap into ImageView 
     imageView.setImageBitmap(bmp); 

     return imageView; 
    } 
} 

Dzięki

Answer 6

myślę prosicie o kurczący Rozmiar obrazu:

public Bitmap ShrinkBitmap(String file, int width, int height) 
{ 
    BitmapFactory.Options bmpFactoryOptions = new BitmapFactory.Options(); 
    bmpFactoryOptions.inJustDecodeBounds = true; 
    Bitmap bitmap = BitmapFactory.decodeFile(file, bmpFactoryOptions); 

    int heightRatio = (int) Math.ceil(bmpFactoryOptions.outHeight/(float) height); 
    int widthRatio = (int) Math.ceil(bmpFactoryOptions.outWidth/(float) width); 

    if(heightRatio > 1 || widthRatio > 1) 
    { 
     if(heightRatio > widthRatio) 
     { 
      bmpFactoryOptions.inSampleSize = heightRatio; 
     } 
     else 
     { 
      bmpFactoryOptions.inSampleSize = widthRatio; 
     } 
    } 

    bmpFactoryOptions.inJustDecodeBounds = false; 
    bitmap = BitmapFactory.decodeFile(file, bmpFactoryOptions); 
    return bitmap; 
} 

Answer 7

rozwiązać ten problem w ten sposób, później będzie poprawić kod

protected Void doInBackground(byte[]... data) { 
     FileOutputStream outStream = null; 

     // Write to Internal Storage 
     try { 
      File dir = new File (context.getFilesDir()); 
      dir.mkdirs(); 

      String fileName ="image.jpg"; 
      File outFile = new File(dir, fileName); 
      outFile.setExecutable(true, false); 
      outFile.setWritable(true, false); 
      outStream = new FileOutputStream(outFile); 
      outStream.write(data[0]); 
      outStream.flush(); 
      outStream.close(); 
      InputStream in = new FileInputStream(context.getFilesDir()+"image.jpg"); 
      Bitmap bm2 = BitmapFactory.decodeStream(in); 
      OutputStream stream = new FileOutputStream(String.valueOf(context.getFilesDir()+pathImage+"/"+idPicture+".jpg")); 
      bm2.compress(Bitmap.CompressFormat.JPEG, 50, stream); 
      stream.close(); 
      in.close(); 

     } catch (FileNotFoundException e) { 
      e.printStackTrace(); 
     } catch (IOException e) { 
      e.printStackTrace(); 
     } finally { 
     } 
     return null; 
    } 

Answer 8

Zastosowanie sprężarki (biblioteka kompresji obrazu). wizyta to link dokumentacji kodu

1. dodać zależność w Gradle (poziom app)

   zależności { kompilacji „id.zelory: sprężarka: 2.1.0' }

2. Kompresja obrazu użyć jednego z tych podejścia:

(i) Kompresja pliku graficznego:

File compressedImageFile = new Compressor(this).compressToFile(actualImageFile); 

(ii) Kompresja pliku obrazu do bitmap:

Bitmap compressedImageBitmap = new Compressor(this).compressToBitmap(actualImageFile); 

Answer 9

użyj tej klasy, aby skompresować obraz

import android.content.Context 
import android.graphics.Bitmap 
import android.graphics.BitmapFactory 
import android.graphics.Canvas 
import android.graphics.Matrix 
import android.graphics.Paint 
import android.net.Uri 
import android.os.Environment 
import java.io.* 


class ImageFile(val uri: Uri, name: String) { 

    val filename: String 

    init { 
     val file = File(Environment.getExternalStorageDirectory().toString() + "/Documents") 
     if (!file.exists()) { 
      file.mkdirs() 
     } 
     val fileNoMedia = File(file.absolutePath + "/.nomedia") 
     if (!fileNoMedia.exists()) 
      fileNoMedia.createNewFile() 
     if (name.toLowerCase().endsWith(".pdf")) { 
      filename = file.absolutePath + "/" + System.currentTimeMillis() + ".pdf" 
     } else { 
      filename = file.absolutePath + "/" + System.currentTimeMillis() + ".jpg" 
     } 
    } 

    @Throws(IOException::class) 
    fun copyFileStream(context: Context, uri: Uri): String { 
     if (filename.endsWith(".pdf") || filename.endsWith(".PDF")) { 
      var ins: InputStream? = null 
      var os: OutputStream? = null 
      try { 
       ins = context.getContentResolver().openInputStream(uri) 
       os = FileOutputStream(filename) 
       val buffer = ByteArray(1024) 
       var length: Int = ins.read(buffer) 
       while (length > 0) { 
        os.write(buffer, 0, length); 
        length = ins.read(buffer) 
       } 
      } catch (e: Exception) { 
       e.printStackTrace(); 
      } finally { 
       ins?.close() 
       os?.close() 
      } 
     } else { 
      var ins: InputStream? = null 
      var os: OutputStream? = null 
      try { 
       ins = context.getContentResolver().openInputStream(uri) 
       var scaledBitmap: Bitmap? = null 
       val options = BitmapFactory.Options() 
       options.inJustDecodeBounds = true 
       var bmp = BitmapFactory.decodeStream(ins, null, options) 
       var actualHeight = options.outHeight 
       var actualWidth = options.outWidth 

       //  max Height and width values of the compressed image is taken as 816x612 
       val maxHeight = 816.0f 
       val maxWidth = 612.0f 
       var imgRatio = (actualWidth/actualHeight).toFloat() 
       val 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 = (imgRatio * actualWidth).toInt() 
         actualHeight = maxHeight.toInt() 
        } else if (imgRatio > maxRatio) { 
         imgRatio = maxWidth/actualWidth 
         actualHeight = (imgRatio * actualHeight).toInt() 
         actualWidth = maxWidth.toInt() 
        } else { 
         actualHeight = maxHeight.toInt() 
         actualWidth = maxWidth.toInt() 

        } 
       } 

       //  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 = ByteArray(16 * 1024) 


       try { 
        //   load the bitmap from its path 
        ins.close() 
        ins = context.getContentResolver().openInputStream(uri) 
        bmp = BitmapFactory.decodeStream(ins, null, options) 
       } catch (exception: OutOfMemoryError) { 
        exception.printStackTrace() 

       } 

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

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

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

       val canvas = Canvas(scaledBitmap!!) 
       canvas.matrix = scaleMatrix 
       canvas.drawBitmap(bmp, middleX - bmp.width/2, middleY - bmp.height/2, Paint(Paint.FILTER_BITMAP_FLAG)) 

       os = FileOutputStream(filename) 
       scaledBitmap.compress(Bitmap.CompressFormat.JPEG, 80, os) 
       val buffer = ByteArray(1024) 
       var length: Int = ins.read(buffer) 
       while (length > 0) { 
        os.write(buffer, 0, length); 
        length = ins.read(buffer) 
       } 
      } catch (e: Exception) { 
       e.printStackTrace(); 
      } finally { 
       ins?.close() 
       os?.close() 
      } 
     } 
     return filename 
    } 

    fun calculateInSampleSize(options: BitmapFactory.Options, reqWidth: Int, reqHeight: Int): Int { 
     val height = options.outHeight 
     val width = options.outWidth 
     var inSampleSize = 1 
     if (height > reqHeight || width > reqWidth) { 
      val heightRatio = Math.round(height.toFloat()/reqHeight.toFloat()) 
      val widthRatio = Math.round(width.toFloat()/reqWidth.toFloat()) 
      inSampleSize = if (heightRatio < widthRatio) heightRatio else widthRatio 
     } 
     val totalPixels = (width * height).toFloat() 
     val totalReqPixelsCap = (reqWidth * reqHeight * 2).toFloat() 
     while (totalPixels/(inSampleSize * inSampleSize) > totalReqPixelsCap) { 
      inSampleSize++ 
     } 

     return inSampleSize 
    } 
} 

https://lalitjadav007.blogspot.in/2017/08/compress-image-in-android.html

Answer 10

Można spróbować ten kod

public class ScalingUtilities { 

    /** 
    * Utility function for decoding an image resource. The decoded bitmap will 
    * be optimized for further scaling to the requested destination dimensions 
    * and scaling logic. 
    * 
    * @param res The resources object containing the image data 
    * @param resId The resource id of the image data 
    * @param dstWidth Width of destination area 
    * @param dstHeight Height of destination area 
    * @param scalingLogic Logic to use to avoid image stretching 
    * @return Decoded bitmap 
    */ 
    public static Bitmap decodeResource(Resources res, int resId, int dstWidth, int dstHeight, 
      ScalingLogic scalingLogic) { 
     Options options = new Options(); 
     options.inJustDecodeBounds = true; 
     BitmapFactory.decodeResource(res, resId, options); 
     options.inJustDecodeBounds = false; 
     options.inSampleSize = calculateSampleSize(options.outWidth, options.outHeight, dstWidth, 
       dstHeight, scalingLogic); 
     Bitmap unscaledBitmap = BitmapFactory.decodeResource(res, resId, options); 

     return unscaledBitmap; 
    } 
    public static Bitmap decodeFile(String path, int dstWidth, int dstHeight, 
      ScalingLogic scalingLogic) { 
     Options options = new Options(); 
     options.inJustDecodeBounds = true; 
     BitmapFactory.decodeFile(path, options); 
     options.inJustDecodeBounds = false; 
     options.inSampleSize = calculateSampleSize(options.outWidth, options.outHeight, dstWidth, 
       dstHeight, scalingLogic); 
     Bitmap unscaledBitmap = BitmapFactory.decodeFile(path, options); 

     return unscaledBitmap; 
    } 

    /** 
    * Utility function for creating a scaled version of an existing bitmap 
    * 
    * @param unscaledBitmap Bitmap to scale 
    * @param dstWidth Wanted width of destination bitmap 
    * @param dstHeight Wanted height of destination bitmap 
    * @param scalingLogic Logic to use to avoid image stretching 
    * @return New scaled bitmap object 
    */ 
    public static Bitmap createScaledBitmap(Bitmap unscaledBitmap, int dstWidth, int dstHeight, 
      ScalingLogic scalingLogic) { 
     Rect srcRect = calculateSrcRect(unscaledBitmap.getWidth(), unscaledBitmap.getHeight(), 
       dstWidth, dstHeight, scalingLogic); 
     Rect dstRect = calculateDstRect(unscaledBitmap.getWidth(), unscaledBitmap.getHeight(), 
       dstWidth, dstHeight, scalingLogic); 
     Bitmap scaledBitmap = Bitmap.createBitmap(dstRect.width(), dstRect.height(), 
       Config.ARGB_8888); 
     Canvas canvas = new Canvas(scaledBitmap); 
     canvas.drawBitmap(unscaledBitmap, srcRect, dstRect, new Paint(Paint.FILTER_BITMAP_FLAG)); 

     return scaledBitmap; 
    } 

    /** 
    * ScalingLogic defines how scaling should be carried out if source and 
    * destination image has different aspect ratio. 
    * 
    * CROP: Scales the image the minimum amount while making sure that at least 
    * one of the two dimensions fit inside the requested destination area. 
    * Parts of the source image will be cropped to realize this. 
    * 
    * FIT: Scales the image the minimum amount while making sure both 
    * dimensions fit inside the requested destination area. The resulting 
    * destination dimensions might be adjusted to a smaller size than 
    * requested. 
    */ 
    public static enum ScalingLogic { 
     CROP, FIT 
    } 

    /** 
    * Calculate optimal down-sampling factor given the dimensions of a source 
    * image, the dimensions of a destination area and a scaling logic. 
    * 
    * @param srcWidth Width of source image 
    * @param srcHeight Height of source image 
    * @param dstWidth Width of destination area 
    * @param dstHeight Height of destination area 
    * @param scalingLogic Logic to use to avoid image stretching 
    * @return Optimal down scaling sample size for decoding 
    */ 
    public static int calculateSampleSize(int srcWidth, int srcHeight, int dstWidth, int dstHeight, 
      ScalingLogic scalingLogic) { 
     if (scalingLogic == ScalingLogic.FIT) { 
      final float srcAspect = (float)srcWidth/(float)srcHeight; 
      final float dstAspect = (float)dstWidth/(float)dstHeight; 

      if (srcAspect > dstAspect) { 
       return srcWidth/dstWidth; 
      } else { 
       return srcHeight/dstHeight; 
      } 
     } else { 
      final float srcAspect = (float)srcWidth/(float)srcHeight; 
      final float dstAspect = (float)dstWidth/(float)dstHeight; 

      if (srcAspect > dstAspect) { 
       return srcHeight/dstHeight; 
      } else { 
       return srcWidth/dstWidth; 
      } 
     } 
    } 

    /** 
    * Calculates source rectangle for scaling bitmap 
    * 
    * @param srcWidth Width of source image 
    * @param srcHeight Height of source image 
    * @param dstWidth Width of destination area 
    * @param dstHeight Height of destination area 
    * @param scalingLogic Logic to use to avoid image stretching 
    * @return Optimal source rectangle 
    */ 
    public static Rect calculateSrcRect(int srcWidth, int srcHeight, int dstWidth, int dstHeight, 
      ScalingLogic scalingLogic) { 
     if (scalingLogic == ScalingLogic.CROP) { 
      final float srcAspect = (float)srcWidth/(float)srcHeight; 
      final float dstAspect = (float)dstWidth/(float)dstHeight; 

      if (srcAspect > dstAspect) { 
       final int srcRectWidth = (int)(srcHeight * dstAspect); 
       final int srcRectLeft = (srcWidth - srcRectWidth)/2; 
       return new Rect(srcRectLeft, 0, srcRectLeft + srcRectWidth, srcHeight); 
      } else { 
       final int srcRectHeight = (int)(srcWidth/dstAspect); 
       final int scrRectTop = (int)(srcHeight - srcRectHeight)/2; 
       return new Rect(0, scrRectTop, srcWidth, scrRectTop + srcRectHeight); 
      } 
     } else { 
      return new Rect(0, 0, srcWidth, srcHeight); 
     } 
    } 

    /** 
    * Calculates destination rectangle for scaling bitmap 
    * 
    * @param srcWidth Width of source image 
    * @param srcHeight Height of source image 
    * @param dstWidth Width of destination area 
    * @param dstHeight Height of destination area 
    * @param scalingLogic Logic to use to avoid image stretching 
    * @return Optimal destination rectangle 
    */ 
    public static Rect calculateDstRect(int srcWidth, int srcHeight, int dstWidth, int dstHeight, 
      ScalingLogic scalingLogic) { 
     if (scalingLogic == ScalingLogic.FIT) { 
      final float srcAspect = (float)srcWidth/(float)srcHeight; 
      final float dstAspect = (float)dstWidth/(float)dstHeight; 

      if (srcAspect > dstAspect) { 
       return new Rect(0, 0, dstWidth, (int)(dstWidth/srcAspect)); 
      } else { 
       return new Rect(0, 0, (int)(dstHeight * srcAspect), dstHeight); 
      } 
     } else { 
      return new Rect(0, 0, dstWidth, dstHeight); 
     } 
    } 


    public static String decodeFile(String path,int DESIREDWIDTH, int DESIREDHEIGHT, int type) { 
     String strMyImagePath = null; 
     Bitmap scaledBitmap = null; 
     Bitmap rotated = null; 

     try { 
      // Part 1: Decode image 
      Bitmap unscaledBitmap = ScalingUtilities.decodeFile(path, DESIREDWIDTH, DESIREDHEIGHT, ScalingLogic.FIT); 

//   if (!(unscaledBitmap.getWidth() <= DESIREDWIDTH && unscaledBitmap.getHeight() <= DESIREDHEIGHT)) { 
//    // Part 2: Scale image 
//    scaledBitmap = ScalingUtilities.createScaledBitmap(unscaledBitmap, DESIREDWIDTH, DESIREDHEIGHT, ScalingLogic.FIT); 
//   } else { 
//    unscaledBitmap.recycle(); 
//    return path; 
//   } 

      // Store to tmp file 
      scaledBitmap = ScalingUtilities.createScaledBitmap(unscaledBitmap, DESIREDWIDTH, DESIREDHEIGHT, ScalingLogic.FIT); 

      String extr = Environment.getExternalStorageDirectory().toString(); 
      File mFolder = new File(extr + com.vt.vsmart.utils.Config.SD_PATH+"/image"); 
      if (!mFolder.exists()) { 
       mFolder.mkdir(); 
      } 

      String s = type+"temp.jpg"; 

      File f = new File(mFolder.getAbsolutePath(), s); 

      strMyImagePath = f.getAbsolutePath(); 
      FileOutputStream fos = null; 
      try { 
       fos = new FileOutputStream(f); 
//    scaledBitmap.compress(Bitmap.CompressFormat.JPEG, 95, fos); 

       // quay anh 90 do 
       Matrix matrix = new Matrix(); 

       matrix.postRotate(90); 

       rotated = Bitmap.createBitmap(scaledBitmap, 0, 0, scaledBitmap.getWidth(), scaledBitmap.getHeight(), matrix, true); 

       rotated.compress(Bitmap.CompressFormat.JPEG, 95, fos); 

       fos.flush(); 
       fos.close(); 
      } catch (FileNotFoundException e) { 

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

       e.printStackTrace(); 
      } 

//   scaledBitmap.recycle(); 
      rotated.recycle(); 
     } catch (Throwable e) { 
     } 

     if (strMyImagePath == null) { 
      return path; 
     } 
     return strMyImagePath; 

    } 

    // check anh bi quay 
    public int getCameraPhotoOrientation(Context context, Uri imageUri, String imagePath){ 
     int rotate = 0; 
     try { 
      context.getContentResolver().notifyChange(imageUri, null); 
      File imageFile = new File(imagePath); 

      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; 
      } 

//   Log.i("RotateImage", "Exif orientation: " + orientation); 
//   Log.i("RotateImage", "Rotate value: " + rotate); 
     } catch (Exception e) { 
      e.printStackTrace(); 
     } 
     return rotate; 
    } 

} 

to praca dla mnie. Mam nadzieję, że to cię rozwiąże!

Answer 11

Po prostu zapisz format pliku jako "image.WEBP", działa dla mnie. To kompresuje obraz 3mb do 37,5kb.

Przykład:

ByteArrayOutputStream out = new ByteArrayOutputStream(); 
bitmap.compress(Bitmap.CompressFormat.WEBP,50, out);