Obsługa dużych Bitmap

Po kilku dniach zmagania się z unikaniem wszystkich OutOfMemory błędów, które otrzymywałem z różnymi urządzeniami, tworzę to:

private Bitmap getDownsampledBitmap(Context ctx, Uri uri, int targetWidth, int targetHeight) {
    Bitmap bitmap = null;
    try {
        BitmapFactory.Options outDimens = getBitmapDimensions(uri);

        int sampleSize = calculateSampleSize(outDimens.outWidth, outDimens.outHeight, targetWidth, targetHeight);

        bitmap = downsampleBitmap(uri, sampleSize);

    } catch (Exception e) {
        //handle the exception(s)
    }

    return bitmap;
}

private BitmapFactory.Options getBitmapDimensions(Uri uri) throws FileNotFoundException, IOException {
    BitmapFactory.Options outDimens = new BitmapFactory.Options();
    outDimens.inJustDecodeBounds = true; // the decoder will return null (no bitmap)

    InputStream is= getContentResolver().openInputStream(uri);
    // if Options requested only the size will be returned
    BitmapFactory.decodeStream(is, null, outDimens);
    is.close();

    return outDimens;
}

private int calculateSampleSize(int width, int height, int targetWidth, int targetHeight) {
    int inSampleSize = 1;

    if (height > targetHeight || width > targetWidth) {

        // Calculate ratios of height and width to requested height and
        // width
        final int heightRatio = Math.round((float) height
                / (float) targetHeight);
        final int widthRatio = Math.round((float) width / (float) targetWidth);

        // Choose the smallest ratio as inSampleSize value, this will
        // guarantee
        // a final image with both dimensions larger than or equal to the
        // requested height and width.
        inSampleSize = heightRatio < widthRatio ? heightRatio : widthRatio;
    }
    return inSampleSize;
}

private Bitmap downsampleBitmap(Uri uri, int sampleSize) throws FileNotFoundException, IOException {
    Bitmap resizedBitmap;
    BitmapFactory.Options outBitmap = new BitmapFactory.Options();
    outBitmap.inJustDecodeBounds = false; // the decoder will return a bitmap
    outBitmap.inSampleSize = sampleSize;

    InputStream is = getContentResolver().openInputStream(uri);
    resizedBitmap = BitmapFactory.decodeStream(is, null, outBitmap);
    is.close();

    return resizedBitmap;
}

Ta metoda działa ze wszystkimi urządzeniami, które testowałem, ale myślę, że jakość może być lepsza przy użyciu innego procesu, którego nie jestem świadomy.

Mam nadzieję, że mój kod pomoże innym programistom w tej samej sytuacji. Doceniam również, jeśli starszy programista może pomóc, dając sugestię o innym procesie, aby uniknąć utraty (mniej) jakości w procesie.

To, co zrobiłem sam, to:

• użyj inJustDecodeBounds, Aby uzyskać oryginalny rozmiar obrazu
• mają stałą maksymalną powierzchnię do ładowania bitmapy (powiedzmy 1Mpixels)
• sprawdź, czy powierzchnia obrazu jest poniżej limitu, jeśli tak, to załaduj ją bezpośrednio
• Jeśli nie Oblicz idealną szerokość i wysokość, na której powinieneś załadować bitmapę, aby pozostać poniżej maksymalnej powierzchni(jest kilka prostych obliczeń do zrobienia tutaj). Daje to współczynnik pływaka, który chcesz zastosować podczas ładowania bitmap
• Teraz chcesz przetłumaczyć ten stosunek na odpowiedni inSampleSize (Moc 2, która nie pogarsza jakości obrazu). Używam tej funkcji:

int k = Integer.highestOneBit((int)Math.floor(ratio));
if(k==0) return 1;
else return k;

• Następnie, ponieważ bitmapy będą ładowane z nieco wyższą rozdzielczością niż maksymalna powierzchnia (ponieważ trzeba było użyć mniejszej mocy 2), będziesz musiał zmienić rozmiar bitmapy, ale będzie to znacznie szybsze.