"Bitmap zu groß, um in eine Textur hochgeladen zu werden"

Ich lade eine Bitmap in eine ImageView und sehe diesen Fehler. Ich nehme an, diese Beschränkung bezieht sich auf eine Größenbeschränkung für OpenGL-Hardwaretexturen (2048 x 2048). Das Bild, das ich laden muss, ist ein Pinch-Zoom-Bild mit einer Höhe von etwa 4.000 Pixel.

Ich habe versucht, die Hardwarebeschleunigung im Manifest auszuschalten, aber keine Freude.

    <application
        android:hardwareAccelerated="false"
        ....
        >

Ist es möglich, ein Bild mit mehr als 2048 Pixel in eine ImageView zu laden?

Das gesamte Rendering basiert auf OpenGL. Nein, Sie können dieses Limit nicht überschreiten ( GL_MAX_TEXTURE_SIZEabhängig vom Gerät, aber das Minimum ist 2048 x 2048, sodass alle Bilder unter 2048 x 2048 passen).

Wenn Sie bei so großen Bildern verkleinern und ein Mobiltelefon verwenden möchten, sollten Sie ein System einrichten, das dem ähnelt, das Sie beispielsweise in Google Maps sehen. Mit dem Bild in mehrere Teile und mehrere Definitionen aufgeteilt.

Sie können das Bild auch verkleinern, bevor Sie es anzeigen (siehe Antwort von user1352407) von auf diese Frage).

Achten Sie auch darauf, in welchen Ordner Sie das Bild legen. Android kann Bilder automatisch skalieren. Schauen Sie sich die Antwort von Pilot_51 auf diese Frage an.

Dies ist keine direkte Antwort auf die Frage (Laden von Bildern> 2048), sondern eine mögliche Lösung für alle, bei denen der Fehler auftritt.

In meinem Fall war das Bild in beiden Dimensionen kleiner als 2048 (um genau zu sein 1280 x 727), und das Problem trat speziell bei einem Galaxy Nexus auf. Das Bild befand sich im drawableOrdner und in keinem der qualifizierten Ordner. Android geht davon aus, dass Drawables ohne Dichtequalifizierer mdpi sind, und skaliert sie für andere Dichten nach oben oder unten, in diesem Fall 2x für xhdpi. drawable-nodpiDas Problem wurde behoben, indem das Bild des Täters verschoben wurde, um eine Skalierung zu verhindern.

Ich habe das Bild folgendermaßen verkleinert:

ImageView iv  = (ImageView)waypointListView.findViewById(R.id.waypoint_picker_photo);
Bitmap d = new BitmapDrawable(ctx.getResources() , w.photo.getAbsolutePath()).getBitmap();
int nh = (int) ( d.getHeight() * (512.0 / d.getWidth()) );
Bitmap scaled = Bitmap.createScaledBitmap(d, 512, nh, true);
iv.setImageBitmap(scaled);

Anstatt stundenlang zu versuchen, diesen gesamten Downsampling-Code manuell zu schreiben / zu debuggen, sollten Sie ihn verwenden Picasso. Es wurde für den Umgang mit gemachtbitmaps allen Arten und / oder Größen gemacht.

Ich habe diese einzelne Codezeile verwendet, um mein Problem "Bitmap zu groß ..." zu entfernen :

Picasso.load(resourceId).fit().centerCrop().into(imageView);

Das Hinzufügen der folgenden 2 Attribute in ( AndroidManifest.xml) hat bei mir funktioniert:

android:largeHeap="true"
android:hardwareAccelerated="false"

Das Ändern der Bilddatei in einen drawable-nodpiOrdner von drawableOrdner zu Ordner hat bei mir funktioniert.

Ich habe Picasso benutzt und hatte das gleiche Problem. Das Bild war zumindest in Bezug auf Größe, Breite oder Höhe zu groß. Endlich habe ich hier die Lösung gefunden. Sie können das große Bild entsprechend der Anzeigegröße verkleinern und das Seitenverhältnis beibehalten:

    public Point getDisplaySize(Display display) {
    Point size = new Point();

    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB_MR2) {
        display.getSize(size);
    } else {
        int width = display.getWidth();
        int height = display.getHeight();
        size = new Point(width, height);
    }

    return size;
}

und verwenden Sie diese Methode zum Laden des Bildes von Picasso:

    final Point displySize = getDisplaySize(getWindowManager().getDefaultDisplay());
        final int size = (int) Math.ceil(Math.sqrt(displySize.x * displySize.y));
        Picasso.with(this)
                .load(urlSource)
                .resize(size, size)
                .centerInside()
                .into(imageViewd);

Für eine bessere Leistung können Sie das Bild auch nach Breite und Höhe des Bildschirms herunterladen, nicht nach dem gesamten Bild:

    public String reviseImageUrl(final Integer displayWidth,     final Integer displayHeight,
        final String originalImageUrl) {
    final String revisedImageUrl;

    if (displayWidth == null && displayHeight == null) {
        revisedImageUrl = originalImageUrl;
    } else {
        final Uri.Builder uriBuilder = Uri.parse(originalImageUrl).buildUpon();

        if (displayWidth != null && displayWidth > 0) {
            uriBuilder.appendQueryParameter(QUERY_KEY_DISPLAY_WIDTH, String.valueOf(displayWidth));
        }

        if (displayHeight != null && displayHeight > 0) {
            uriBuilder.appendQueryParameter(QUERY_KEY_DISPLAY_HEIGHT, String.valueOf(displayHeight));
        }

        revisedImageUrl = uriBuilder.toString();
    }

    return revisedImageUrl;
}

    final String newImageUlr = reviseImageUrl(displySize.x, displySize.y, urlSource);

und dann:

    Picasso.with(this)
                .load(newImageUlr)
                .resize(size, size)
                .centerInside()
                .into(imageViewd);

BEARBEITEN: getDisplaySize ()

display.getWidth()/getHeight()ist veraltet. Anstelle von DisplayGebrauch DisplayMetrics.

public Point getDisplaySize(DisplayMetrics displayMetrics) {
        int width = displayMetrics.widthPixels;
        int height = displayMetrics.heightPixels;
        return new Point(width, height);
}

BitmapRegionDecoder macht den Trick.

Sie können überschreiben onDraw(Canvas canvas), einen neuen Thread starten und den für den Benutzer sichtbaren Bereich dekodieren.

Wie von Larcho ausgeführt, können Sie ab API-Ebene 10 BitmapRegionDecoderbestimmte Regionen aus einem Bild laden und so ein großes Bild in hoher Auflösung anzeigen, indem Sie nur die benötigten Regionen im Speicher zuweisen. Ich habe kürzlich eine Bibliothek entwickelt, die die Visualisierung großer Bilder mit Touch-Gesten-Handhabung ermöglicht. Der Quellcode und Beispiele finden Sie hier .

Ansichtsebene

Sie können die Hardwarebeschleunigung für eine einzelne Ansicht zur Laufzeit mit dem folgenden Code deaktivieren:

myView.setLayerType (View.LAYER_TYPE_SOFTWARE, null);

Ich habe das gleiche Problem durchlaufen, hier ist meine Lösung. Stellen Sie die Breite des Bildes auf die Breite des Android-Bildschirms ein und skalieren Sie dann die Höhe

Bitmap myBitmap = BitmapFactory.decodeFile(image.getAbsolutePath());
Display display = getWindowManager().getDefaultDisplay();
Point size = new Point();
display.getSize(size);
int width = size.x;
int height = size.y;
Log.e("Screen width ", " "+width);
Log.e("Screen height ", " "+height);
Log.e("img width ", " "+myBitmap.getWidth());
Log.e("img height ", " "+myBitmap.getHeight());
float scaleHt =(float) width/myBitmap.getWidth();
Log.e("Scaled percent ", " "+scaleHt);
Bitmap scaled = Bitmap.createScaledBitmap(myBitmap, width, (int)(myBitmap.getWidth()*scaleHt), true);
myImage.setImageBitmap(scaled);

Dies ist besser für jede Größe Android-Bildschirm. Lassen Sie mich wissen, ob es für Sie funktioniert.

Bild verkleinern:

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

// Set height and width in options, does not return an image and no resource taken
BitmapFactory.decodeStream(imagefile, null, options);

int pow = 0;
while (options.outHeight >> pow > reqHeight || options.outWidth >> pow > reqWidth)
    pow += 1;
options.inSampleSize = 1 << pow; 
options.inJustDecodeBounds = false;
image = BitmapFactory.decodeStream(imagefile, null, options);

Das Bild wird auf die Größe von reqHeight und reqWidth verkleinert. Soweit ich weiß, nimmt inSampleSize nur eine Potenz von 2 Werten auf.

Verwenden Sie die Glide-Bibliothek, anstatt sie direkt in die Bildansicht zu laden

Gleiten: https://github.com/bumptech/glide

Glide.with(this).load(Uri.parse(filelocation))).into(img_selectPassportPic);

Ich habe alle oben genannten Lösungen viele Stunden lang nacheinander ausprobiert, und keine schien zu funktionieren! Schließlich habe ich mich nach einem offiziellen Beispiel umgesehen, um Bilder mit der Android-Kamera aufzunehmen und anzuzeigen. Das offizielle Beispiel ( hier ) gab mir endlich die einzige Methode, die funktionierte. Unten präsentiere ich die Lösung, die ich in dieser Beispiel-App gefunden habe:

public void setThumbnailImageAndSave(final ImageView imgView, File imgFile) {

            /* There isn't enough memory to open up more than a couple camera photos */
    /* So pre-scale the target bitmap into which the file is decoded */

    /* Get the size of the ImageView */
    int targetW = imgView.getWidth();
    int targetH = imgView.getHeight();

    /* Get the size of the image */
    BitmapFactory.Options bmOptions = new BitmapFactory.Options();
    bmOptions.inJustDecodeBounds = true;
    BitmapFactory.decodeFile(imgFile.getAbsolutePath(), 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(imgFile.getAbsolutePath(), bmOptions);

    /* Associate the Bitmap to the ImageView */
    imgView.setImageBitmap(bitmap);
    imgView.setVisibility(View.VISIBLE);
}

HINWEIS FÜR DIE, DIE BILDER VON KLEINER GRÖSSE EINSTELLEN MÖCHTEN:

Die Lösung von Pilot_51 (Verschieben Ihrer Bilder in einen drawable-nodpiOrdner) funktioniert, hat jedoch ein weiteres Problem: Sie macht Bilder ZU KLEIN auf dem Bildschirm , wenn nicht die Bilder , die auf eine sehr große Größe verändert werden (wie 2000 x 3800) Auflösung fit Bildschirm - dann macht es Ihre Anwendung schwerer .

LÖSUNG : Legendrawable-hdpi Sie Ihre Bilddateien ein - Es hat wie ein Zauber für mich funktioniert.

Die Verwendung des richtigen zeichnbaren Unterordners hat es für mich gelöst. Meine Lösung bestand darin, mein Bild in voller Auflösung (1920 x 1200) in den Ordner drawable-xhdpi anstatt in den Ordner drawable zu legen .

Ich habe auch ein verkleinertes Bild (1280x800) in den Ordner drawable-hdpi gelegt .

Diese beiden Auflösungen stimmen mit den von mir programmierten Nexus 7-Tablets 2013 und 2012 überein. Ich habe die Lösung auch auf einigen anderen Tabletten getestet.

@Override
protected void onActivityResult(int requestCode, int resultCode, Intent data) {

    super.onActivityResult(requestCode, resultCode, data);
    ///*
    if (requestCode == PICK_FROM_FILE && resultCode == RESULT_OK && null != data){



        uri = data.getData();

        String[] prjection ={MediaStore.Images.Media.DATA};

        Cursor cursor = getContentResolver().query(uri,prjection,null,null,null);

        cursor.moveToFirst();

        int columnIndex = cursor.getColumnIndex(prjection[0]);

        ImagePath = cursor.getString(columnIndex);

        cursor.close();

        FixBitmap = BitmapFactory.decodeFile(ImagePath);

        ShowSelectedImage = (ImageView)findViewById(R.id.imageView);

      //  FixBitmap = new BitmapDrawable(ImagePath);
        int nh = (int) ( FixBitmap.getHeight() * (512.0 / FixBitmap.getWidth()) );
        FixBitmap = Bitmap.createScaledBitmap(FixBitmap, 512, nh, true);

       // ShowSelectedImage.setImageBitmap(BitmapFactory.decodeFile(ImagePath));

        ShowSelectedImage.setImageBitmap(FixBitmap);

    }
}

Dieser Code ist Arbeit