“Bitmap trop volumineux pour être envoyé dans une texture”

Tous rendu est basé sur OpenGL, donc non, vous ne pouvez pas aller au delà de cette limite (GL_MAX_TEXTURE_SIZE dépend de l'appareil, mais le minimum est de 2048x2048 pixels, de sorte que toute image inférieure à 2048x2048 sera adaptée).

Avec de telles images, si vous souhaitez faire un zoom avant, et dans un mobile, vous devez configurer un système similaire à ce que vous voyez dans google maps par exemple. Avec le diviser l'image en plusieurs morceaux, et plusieurs définitions.

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

Et aussi, attention à bien le dossier dans lequel vous mettez l'image, Android peut automatiquement à l'échelle des images. Jetez un oeil à Pilot_51 réponse ci-dessous sur cette question.

J'ai réduit l'image de cette façon:

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

La modification de l'image du fichier à drawable-nodpi dossier de drawable dossier a fonctionné pour moi.

J'ai utilisé Picasso et avait le même problème. l'image était trop grand, au moins sur la taille, la largeur ou la hauteur. j'ai enfin trouvé la solution ici. vous pouvez mettre à l'échelle l'image de grande taille, en fonction de la taille de l'affichage et aussi garder le ratio d'aspect:

    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 l'utilisation de cette méthode pour le chargement de l'image de 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);

aussi pour de meilleures performances, vous pouvez télécharger l'image en fonction de la largeur et de la hauteur de l'écran, et non l'ensemble de l'image:

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

et puis:

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

EDIT: getDisplaySize()

display.getWidth()/getHeight() est obsolète. Au lieu de Display utilisation DisplayMetrics.

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

Comme indiqué par Larcho, à partir de l'API de niveau 10, vous pouvez utiliser BitmapRegionDecoder à la charge des régions spécifiques à partir d'une image et avec cela, vous pouvez accomplir pour afficher une grande image en haute résolution par l'allocation en mémoire juste le nécessaire régions. J'ai récemment développé une lib qui offre la visualisation d'images en grand avec touch geste de la manipulation. Le code source et des échantillons sont disponibles ici.

Au niveau de la vue

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

mavue.setLayerType(point de Vue.LAYER_TYPE_SOFTWARE, null);

J'ai essayé toutes les solutions ci-dessus, l'un après l'autre, pour de très nombreuses heures, et aucun ne semble fonctionner! Finalement, j'ai décidé de regarder autour pour un fonctionnaire exemple en ce qui concerne la capture des images avec Android appareil photo, et de les afficher. L'officiel de l'exemple (ici), enfin m'a donné la seule méthode qui a fonctionné. Ci-dessous je vous présente la solution que j'ai trouvé 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);
}

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

Pilot_51 la solution de (déplacement à vos images drawable-nodpi dossier) fonctionne, mais a un autre problème:
Il fait des images TROP PETITE sur l'écran, sauf si les images sont redimensionnées à une très large (comme 2000 x 3800) résolution pour adapter à l'écran -- puis, il rend votre application plus lourd.

SOLUTION: mettez vos fichiers image dans drawable-hdpi -- Il a travaillé comme un charme pour moi.

@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 un travail