"Bitmap muito grande para ser carregado em uma textura"

Estou carregando um bitmap em um ImageView e vendo esse erro. Entendo que esse limite se refere a um limite de tamanho para texturas de hardware OpenGL (2048x2048). A imagem que preciso carregar é uma imagem com zoom de pitada de cerca de 4.000 pixels de altura.

Tentei desativar a aceleração de hardware no manifesto, mas sem alegria.

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

É possível carregar uma imagem maior que 2048 pixels em um ImageView?

Toda a renderização é baseada no OpenGL; portanto, você não pode ultrapassar esse limite ( GL_MAX_TEXTURE_SIZEdepende do dispositivo, mas o mínimo é 2048x2048; portanto, qualquer imagem menor que 2048x2048 será adequada).

Com imagens tão grandes, se você quiser diminuir o zoom e em um celular, configure um sistema semelhante ao que vê no google maps, por exemplo. Com a imagem dividida em várias partes e várias definições.

Ou você pode reduzir a imagem antes de exibi-la (consulte a resposta do usuário1352407 nesta pergunta).

Além disso, tenha cuidado com a pasta em que você coloca a imagem, o Android pode ampliar automaticamente as imagens. Dê uma olhada na resposta de Pilot_51 abaixo sobre esta questão.

Esta não é uma resposta direta à pergunta (carregamento de imagens> 2048), mas uma solução possível para qualquer pessoa que esteja enfrentando o erro.

No meu caso, a imagem era menor que 2048 em ambas as dimensões (1280x727, para ser exato) e o problema ocorreu especificamente no Galaxy Nexus. A imagem estava na drawablepasta e nenhuma das pastas qualificadas. O Android assume que os drawables sem um qualificador de densidade sejam mdpi e os dimensione para cima ou para baixo para outras densidades; nesse caso, aumentado em 2x para xhdpi. Mover a imagem do culpado drawable-nodpipara evitar o dimensionamento resolveu o problema.

Eu reduzi a imagem desta maneira:

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

Em vez de gastar horas e horas tentando escrever / depurar todo esse código de redução de amostragem manualmente, por que não usar Picasso? Foi feito para lidar com bitmapstodos os tipos e / ou tamanhos.

Eu usei essa única linha de código para remover o meu problema "bitmap muito grande ...." :

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

A adição dos 2 atributos a seguir em ( AndroidManifest.xml) funcionou para mim:

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

Alterar o arquivo de imagem para drawable-nodpipasta da drawablepasta funcionou para mim.

Eu usei Picasso e tive o mesmo problema. a imagem era muito grande, pelo menos no tamanho, largura ou altura. finalmente encontrei a solução aqui. você pode reduzir a imagem grande de acordo com o tamanho da tela e também manter a proporção:

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

e use este método para carregar a imagem do 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);

também para um melhor desempenho, você pode fazer o download da imagem de acordo com a largura e a altura da tela, e não toda a imagem:

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

e depois:

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

EDIT: getDisplaySize ()

display.getWidth()/getHeight()está obsoleto. Em vez de Displayusar DisplayMetrics.

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

BitmapRegionDecoder faz o truque.

Você pode substituir onDraw(Canvas canvas), iniciar um novo Thread e decodificar a área visível para o usuário.

Conforme apontado por Larcho, a partir do nível 10 da API, você pode BitmapRegionDecodercarregar regiões específicas de uma imagem e, com isso, pode mostrar uma imagem grande em alta resolução alocando na memória apenas as regiões necessárias. Recentemente, desenvolvi uma biblioteca que fornece a visualização de imagens grandes com manipulação de gestos por toque. O código fonte e as amostras estão disponíveis aqui .

Ver nível

Você pode desativar a aceleração de hardware para uma visualização individual em tempo de execução com o seguinte código:

myView.setLayerType (View.LAYER_TYPE_SOFTWARE, nulo);

Corri pelo mesmo problema, aqui está a minha solução. defina a largura da imagem igual à largura da tela do Android e depois dimensione a altura

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

Isto é melhor para qualquer tamanho de tela Android. deixe-me saber se funciona para você.

Reduzir imagem:

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

A imagem será reduzida no tamanho de reqHeight e reqWidth. Pelo que entendi, inSampleSize apenas absorve uma potência de 2 valores.

Use a biblioteca Glide em vez de carregar diretamente na visualização de imagem

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

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

Tentei todas as soluções acima, uma após a outra, por muitas horas, e nenhuma parecia funcionar! Finalmente, decidi procurar um exemplo oficial sobre a captura de imagens com a câmera do Android e exibi-las. O exemplo oficial ( aqui ) finalmente me deu o único método que funcionou. Abaixo, apresento a solução que encontrei nesse aplicativo de exemplo:

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

NOTA PARA QUEM QUER COLOCAR IMAGENS DE TAMANHO PEQUENO:

A solução do Pilot_51 (mover suas imagens para a drawable-nodpipasta) funciona, mas tem outro problema: torna as imagens MUITO PEQUENAS na tela, a menos que as imagens sejam redimensionadas para uma resolução muito grande (como 2000 x 3800) para caber na tela - e torna seu aplicativo mais pesado .

SOLUÇÃO : coloque seus arquivos de imagem drawable-hdpi- funcionou como um encanto para mim.

Usar a subpasta desenhável correta resolveu isso para mim. Minha solução foi colocar minha imagem em resolução máxima (1920x1200) na pasta drawable-xhdpi , em vez da pasta drawable .

Também coloquei uma imagem reduzida (1280x800) na pasta drawable-hdpi .

Essas duas resoluções correspondem aos tablets Nexus 7 de 2013 e 2012 que estou programando. Também testei a solução em alguns outros tablets.

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

    }
}

Este código é trabalho