"Bitmap trop volumineux pour être chargé dans une texture"

Je charge un bitmap dans un ImageView et vois cette erreur. Je suppose que cette limite concerne une limite de taille pour les textures matérielles OpenGL (2048x2048). L'image que je dois charger est une image à zoom par pincement d'environ 4 000 pixels de haut.

J'ai essayé de désactiver l'accélération matérielle dans le manifeste, mais pas de joie.

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

Est-il possible de charger une image de plus de 2048 pixels dans un ImageView?

Tout le rendu est basé sur OpenGL, donc non, vous ne pouvez pas dépasser cette limite ( GL_MAX_TEXTURE_SIZEdépend de l'appareil, mais le minimum est de 2048x2048, donc toute image inférieure à 2048x2048 conviendra).

Avec des images aussi grandes, si vous souhaitez effectuer un zoom arrière, et dans un mobile, vous devez configurer un système similaire à ce que vous voyez dans google maps par exemple. Avec l'image divisée en plusieurs morceaux et plusieurs définitions.

Ou vous pouvez réduire l'image avant de l'afficher (voir la réponse de user1352407 à cette question).

Et aussi, faites attention dans le dossier dans lequel vous mettez l'image, Android peut automatiquement agrandir les images. Jetez un œil à la réponse de Pilot_51 ci-dessous à cette question.

Ce n'est pas une réponse directe à la question (chargement d'images> 2048), mais une solution possible pour toute personne rencontrant l'erreur.

Dans mon cas, l'image était plus petite que 2048 dans les deux dimensions (1280x727 pour être exact) et le problème a été spécifiquement rencontré sur un Galaxy Nexus. L'image était dans le drawabledossier et aucun des dossiers qualifiés. Android suppose que les dessinables sans qualificatif de densité sont mdpi et les met à l'échelle vers le haut ou vers le bas pour d'autres densités, dans ce cas mis à l'échelle 2x pour xhdpi. Le déplacement de l'image coupable vers drawable-nodpipour éviter la mise à l'échelle a résolu le problème.

J'ai réduit l'image de cette manière:

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

Au lieu de passer des heures et des heures à essayer d'écrire / déboguer manuellement tout ce code de sous-échantillonnage, pourquoi ne pas l'utiliser Picasso? Il a été conçu pour traiter bitmapsde tous types et / ou tailles.

J'ai utilisé cette seule ligne de code pour supprimer mon problème "bitmap trop grand ..." :

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

L'ajout des 2 attributs suivants dans ( AndroidManifest.xml) a fonctionné pour moi:

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

Changer le fichier image en dossier à drawable-nodpipartir du drawabledossier a fonctionné pour moi.

J'ai utilisé Picasso et j'ai eu le même problème. l'image était trop grande au moins en taille, largeur ou hauteur. enfin j'ai trouvé la solution ici. vous pouvez redimensionner la grande image en fonction de la taille d'affichage et également conserver le rapport hauteur / largeur:

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

et utilisez cette méthode pour charger l'image par 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);

également pour de meilleures performances, vous pouvez télécharger l'image en fonction de la largeur et de la hauteur de l'écran d'affichage, pas de l'image entière:

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

puis:

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

MODIFIER: getDisplaySize ()

display.getWidth()/getHeight()est obsolète. Au lieu de l' Displayutiliser DisplayMetrics.

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

BitmapRegionDecoder fait l'affaire.

Vous pouvez remplacer onDraw(Canvas canvas), démarrer un nouveau fil et décoder la zone visible par l'utilisateur.

Comme l'a souligné Larcho, à partir du niveau d'API 10, vous pouvez utiliser BitmapRegionDecoderpour charger des régions spécifiques à partir d'une image et avec cela, vous pouvez accomplir pour afficher une grande image en haute résolution en allouant en mémoire uniquement les régions nécessaires. J'ai récemment développé une bibliothèque qui permet de visualiser de grandes images avec la gestion des gestes tactiles. Le code source et des exemples sont disponibles ici .

Afficher le niveau

Vous pouvez désactiver l'accélération matérielle pour une vue individuelle au moment de l'exécution avec le code suivant:

myView.setLayerType (View.LAYER_TYPE_SOFTWARE, null);

J'ai rencontré le même problème, voici ma solution. définir la largeur de l'image comme la largeur de l'écran Android, puis redimensionner la hauteur

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

C'est mieux pour n'importe quel écran Android de taille. Dites-moi si cela marche pour vous.

Réduire l'image:

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

L'image sera réduite à la taille de reqHeight et reqWidth. Comme je le comprends, inSampleSize ne prend qu'une puissance de 2 valeurs.

Utilisez la bibliothèque Glide au lieu de charger directement dans imageview

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

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

J'ai essayé toutes les solutions ci-dessus, l'une après l'autre, pendant de nombreuses heures, et aucune ne semblait fonctionner! Enfin, j'ai décidé de chercher un exemple officiel concernant la capture d'images avec l'appareil photo d'Android et leur affichage. L'exemple officiel ( ici ), m'a finalement donné la seule méthode qui a fonctionné. Ci-dessous, je présente la solution que j'ai trouvée dans cet exemple d'application:

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

REMARQUE POUR CEUX QUI VEULENT METTRE DES IMAGES DE PETITE TAILLE:

La solution de Pilot_51 (déplacer vos images dans un drawable-nodpidossier) fonctionne, mais présente un autre problème: elle rend les images TROP PETITES à l'écran à moins que les images ne soient redimensionnées à une très grande résolution (comme 2000 x 3800) pour s'adapter à l'écran - alors cela rend votre application plus lourde .

SOLUTION : mettez vos fichiers image dedans drawable-hdpi- Cela a fonctionné comme un charme pour moi.

L'utilisation du sous-dossier dessinable correct a résolu le problème pour moi. Ma solution était de mettre mon image pleine résolution (1920x1200) dans le dossier drawable-xhdpi , au lieu du dossier drawable .

J'ai également mis une image réduite (1280x800) dans le dossier drawable-hdpi .

Ces deux résolutions correspondent aux tablettes Nexus 7 2013 et 2012 que je programme. J'ai également testé la solution sur d'autres tablettes.

@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);

    }
}

Ce code est du travail