एंड्रॉइड में बिटमैप को कैसे आकार दें?

Question

मेरे पास अपने दूरस्थ डेटाबेस से बेस 64 स्ट्रिंग का एक बिटमैप है, ( encodedImageयह बेस 64 के साथ छवि का प्रतिनिधित्व करने वाला स्ट्रिंग है):

profileImage = (ImageView)findViewById(R.id.profileImage);

byte[] imageAsBytes=null;
try {
    imageAsBytes = Base64.decode(encodedImage.getBytes());
} catch (IOException e) {e.printStackTrace();}

profileImage.setImageBitmap(
    BitmapFactory.decodeByteArray(imageAsBytes, 0, imageAsBytes.length)
);

profileImage मेरा ImageView है

ठीक है, लेकिन मुझे ImageViewअपने लेआउट पर दिखाने से पहले इस छवि का आकार बदलना होगा । मुझे इसे 120x120 का आकार बदलना होगा।

क्या कोई मुझे इसका आकार बदलने के लिए कोड बता सकता है?

मेरे द्वारा प्राप्त किए गए उदाहरणों को बेस64 स्ट्रिंग बिटमैप पर लागू नहीं किया जा सकता है।

Comments

एंड्रॉइड में

— रीसेट

Answer 1

परिवर्तन:

profileImage.setImageBitmap(
    BitmapFactory.decodeByteArray(imageAsBytes, 0, imageAsBytes.length)

सेवा:

Bitmap b = BitmapFactory.decodeByteArray(imageAsBytes, 0, imageAsBytes.length)
profileImage.setImageBitmap(Bitmap.createScaledBitmap(b, 120, 120, false));

Comments

मान लीजिए कि आपकी बड़ी रिज़ॉल्यूशन वाली छवि 1200x1200 है और जब आप इसे प्रदर्शित करते हैं, तो यह इमेजव्यू में पूरी हो जाएगी। अगर मैं इसे नीचे पैमाने पर 75% कहता हूं और स्क्रीन इतनी है कि यह स्केल की गई छवि को भी पूरी तरह से इमेजव्यू में प्रदर्शित करता है, तो ऐसी स्क्रीन के लिए क्या किया जाना चाहिए?

— jxgn

CreateScaledBitmap ने मेरे गैलेक्सी टैब 2 पर आउट ऑफ़ मेमोरी एक्सेप्शन फेंका जो कि मेरे लिए बहुत ही अजीब है क्योंकि बहुत सी मेमोरी है और कोई अन्य ऐप नहीं चल रहा है। मैट्रिक्स समाधान हालांकि काम करता है।

— लुडोविक

क्या होगा अगर हम पहलू अनुपात को बचाना चाहते हैं ??

— कीड़े

इसके लिए डीपीआई स्केलिंग के बारे में क्या? मुझे लगता है कि स्केल किए गए बिटमैप को डिवाइस स्क्रीन की ऊँचाई और चौड़ाई पर आधारित होना चाहिए?

— डग रे

Bitmap.createScaledBitmap () का उपयोग करके एक छवि को आधे से अधिक मूल आकार में बदलने के लिए, अलियासिंग कलाकृतियों का उत्पादन कर सकते हैं। आप एक पोस्ट पर एक नज़र डाल सकते हैं जो मैंने लिखा था जहां मैं कुछ विकल्पों का प्रस्ताव करता हूं और गुणवत्ता और प्रदर्शन की तुलना करता हूं।

— पेट्राकेश

Answer 2

import android.graphics.Matrix
public Bitmap getResizedBitmap(Bitmap bm, int newWidth, int newHeight) {
    int width = bm.getWidth();
    int height = bm.getHeight();
    float scaleWidth = ((float) newWidth) / width;
    float scaleHeight = ((float) newHeight) / height;
    // CREATE A MATRIX FOR THE MANIPULATION
    Matrix matrix = new Matrix();
    // RESIZE THE BIT MAP
    matrix.postScale(scaleWidth, scaleHeight);

    // "RECREATE" THE NEW BITMAP
    Bitmap resizedBitmap = Bitmap.createBitmap(
        bm, 0, 0, width, height, matrix, false);
    bm.recycle();
    return resizedBitmap;
}

संपादित करें: जैसा कि @aveschini द्वारा सुझाया गया है, मैंने bm.recycle();मेमोरी लीक के लिए जोड़ा है । कृपया ध्यान दें कि यदि आप कुछ अन्य उद्देश्यों के लिए पिछले ऑब्जेक्ट का उपयोग कर रहे हैं, तो उसी के अनुसार संभाल लें।

Comments

मैंने दोनों बिटमैप की कोशिश की। मुझे लगता है कि मैट्रिक्स दृष्टिकोण के साथ छवि बहुत अधिक स्पष्ट है। मुझे नहीं पता कि यह सामान्य है या सिर्फ इसलिए कि मैं फोन के बजाय एक सिम्युलेटर का उपयोग कर रहा हूं। मेरे जैसे ही मुसीबत का सामना करने वाले किसी व्यक्ति के लिए बस एक संकेत।

— Anson Yao

यहाँ भी आपको ज्यादा बेहतर मेमोरी प्रदर्शन के लिए bm.recycle () जोड़ना होगा

— aveschini

समाधान के लिए धन्यवाद, लेकिन यह बेहतर होगा अगर मापदंडों को फिर से व्यवस्थित किया गया था; public Bitmap getResizedBitmap(Bitmap bm, int newWidth, int newHeight)। मैंने समय निकालकर उसे बिताया। ; पी

— हमला

ध्यान दें कि मैट्रिक्स के लिए सही आयात android.graphics.Matrix है।

— लेव

यह Bitmap.createScaledBitmap () को कॉल करने के समान है। देखें android.googlesource.com/platform/frameworks/base/+/refs/heads/…

— BamsBamx

Answer 3

यदि आपके पास पहले से ही एक बिटमैप है, तो आप आकार बदलने के लिए निम्न कोड का उपयोग कर सकते हैं:

Bitmap originalBitmap = <original initialization>;
Bitmap resizedBitmap = Bitmap.createScaledBitmap(
    originalBitmap, newWidth, newHeight, false);

Comments

@beginner यदि आप छवि का आकार बदलते हैं, तो आप विभिन्न आयामों के आधार पर स्केलिंग कर सकते हैं जो या तो बिटमैप को गलत अनुपात में बदल देते हैं या बिटमैप जानकारी को हटा देते हैं।

— ZenBalance

मैंने अनुपात के आधार पर बिटमैप को आकार देने की कोशिश की, लेकिन तब मुझे यह त्रुटि मिल रही थी। इसके कारण: java.lang.RuntimeException: कैनवस: एक पुनर्नवीनीकरण बिटमैप android.graphics.Bitmap@2291dd13 का उपयोग करने की कोशिश कर रहा है

— शुरुआत

@beginner हर बार बिटमैप का आकार बदलने पर निर्भर करता है कि आप क्या कर रहे हैं, आपको आमतौर पर एक कॉपी बनाने की आवश्यकता होगी जो मौजूदा बिटमैप को आकार देने के बजाय एक नया आकार है (क्योंकि इस मामले में यह बिटमैप के संदर्भ की तरह दिखता था। पहले से ही स्मृति में पुनर्नवीनीकरण)।

— ZenBalance

सही .. मैं इसे करने की कोशिश की और यह अभी काम करता है। धन्यवाद

— शुरुआत

Answer 4

पहलू अनुपात के आधार पर स्केल :

float aspectRatio = yourSelectedImage.getWidth() / 
    (float) yourSelectedImage.getHeight();
int width = 480;
int height = Math.round(width / aspectRatio);

yourSelectedImage = Bitmap.createScaledBitmap(
    yourSelectedImage, width, height, false);

चौड़ाई परिवर्तन के आधार के रूप में ऊंचाई का उपयोग करने के लिए:

int height = 480;
int width = Math.round(height * aspectRatio);

Answer 5

पहलू अनुपात बनाए रखते हुए लक्ष्य आकार और चौड़ाई के साथ बिटमैप को स्केल करें:

int maxHeight = 2000;
int maxWidth = 2000;    
float scale = Math.min(((float)maxHeight / bitmap.getWidth()), ((float)maxWidth / bitmap.getHeight()));

Matrix matrix = new Matrix();
matrix.postScale(scale, scale);

bitmap = Bitmap.createBitmap(bitmap, 0, 0, bitmap.getWidth(), bitmap.getHeight(), matrix, true);

Answer 6

इस कोड को आज़माएं:

BitmapDrawable drawable = (BitmapDrawable) imgview.getDrawable();
Bitmap bmp = drawable.getBitmap();
Bitmap b = Bitmap.createScaledBitmap(bmp, 120, 120, false);

मुझे आशा है कि यह उपयोगी है।

Answer 7

किसी ने पूछा कि इस स्थिति में पहलू अनुपात कैसे रखा जाए:

स्केलिंग के लिए आपके द्वारा उपयोग किए जा रहे कारक की गणना करें और दोनों आयामों के लिए इसका उपयोग करें। लेट्स का कहना है कि आप स्क्रीन को 20% ऊंचाई पर रखना चाहते हैं

int scaleToUse = 20; // this will be our percentage
Bitmap bmp = BitmapFactory.decodeResource(
    context.getResources(), R.drawable.mypng);
int sizeY = screenResolution.y * scaleToUse / 100;
int sizeX = bmp.getWidth() * sizeY / bmp.getHeight();
Bitmap scaled = Bitmap.createScaledBitmap(bmp, sizeX, sizeY, false);

स्क्रीन रिज़ॉल्यूशन प्राप्त करने के लिए आपके पास यह समाधान है: पिक्सेल में स्क्रीन आयाम प्राप्त करें

Answer 8

इसे आज़माएँ: यह फ़ंक्शन आनुपातिक रूप से बिटमैप का आकार बदलता है। जब अंतिम पैरामीटर "X" पर सेट newDimensionXorYकिया जाता है , तो इसे नई चौड़ाई के रूप में माना जाता है और जब "Y" को एक नई ऊंचाई पर सेट किया जाता है।

public Bitmap getProportionalBitmap(Bitmap bitmap, 
                                    int newDimensionXorY, 
                                    String XorY) {
    if (bitmap == null) {
        return null;
    }

    float xyRatio = 0;
    int newWidth = 0;
    int newHeight = 0;

    if (XorY.toLowerCase().equals("x")) {
        xyRatio = (float) newDimensionXorY / bitmap.getWidth();
        newHeight = (int) (bitmap.getHeight() * xyRatio);
        bitmap = Bitmap.createScaledBitmap(
            bitmap, newDimensionXorY, newHeight, true);
    } else if (XorY.toLowerCase().equals("y")) {
        xyRatio = (float) newDimensionXorY / bitmap.getHeight();
        newWidth = (int) (bitmap.getWidth() * xyRatio);
        bitmap = Bitmap.createScaledBitmap(
            bitmap, newWidth, newDimensionXorY, true);
    }
    return bitmap;
}

Answer 9

profileImage.setImageBitmap(
    Bitmap.createScaledBitmap(
        BitmapFactory.decodeByteArray(imageAsBytes, 0, imageAsBytes.length), 
        80, 80, false
    )
);

Answer 10

  public Bitmap scaleBitmap(Bitmap mBitmap) {
        int ScaleSize = 250;//max Height or width to Scale
        int width = mBitmap.getWidth();
        int height = mBitmap.getHeight();
        float excessSizeRatio = width > height ? width / ScaleSize : height / ScaleSize;
         Bitmap bitmap = Bitmap.createBitmap(
                mBitmap, 0, 0,(int) (width/excessSizeRatio),(int) (height/excessSizeRatio));
        //mBitmap.recycle(); if you are not using mBitmap Obj
        return bitmap;
    }

Comments

मेरे लिए यह एक बिट के बाद काम किया फ्लोट अधिकअतिरिक्त तैरना = चौड़ाई> ऊंचाई? (फ्लोट) ((फ्लोट) चौड़ाई / (फ्लोट) स्केल): (फ्लोट) ((फ्लोट) ऊंचाई / (फ्लोट) स्केल);

— Csabi

Answer 11

public static Bitmap resizeBitmapByScale(
            Bitmap bitmap, float scale, boolean recycle) {
        int width = Math.round(bitmap.getWidth() * scale);
        int height = Math.round(bitmap.getHeight() * scale);
        if (width == bitmap.getWidth()
                && height == bitmap.getHeight()) return bitmap;
        Bitmap target = Bitmap.createBitmap(width, height, getConfig(bitmap));
        Canvas canvas = new Canvas(target);
        canvas.scale(scale, scale);
        Paint paint = new Paint(Paint.FILTER_BITMAP_FLAG | Paint.DITHER_FLAG);
        canvas.drawBitmap(bitmap, 0, 0, paint);
        if (recycle) bitmap.recycle();
        return target;
    }
    private static Bitmap.Config getConfig(Bitmap bitmap) {
        Bitmap.Config config = bitmap.getConfig();
        if (config == null) {
            config = Bitmap.Config.ARGB_8888;
        }
        return config;
    }

Answer 12

एपीआई 19 के रूप में, बिटमैप सेटविड (इंट चौड़ाई) और सेटहाइट (इंट ऊंचाई) मौजूद हैं। http://developer.android.com/reference/android/graphics/Bitmap.html

Answer 13

बिटमैप आकार किसी भी प्रदर्शन आकार के आधार पर

public Bitmap bitmapResize(Bitmap imageBitmap) {

    Bitmap bitmap = imageBitmap;
    float heightbmp = bitmap.getHeight();
    float widthbmp = bitmap.getWidth();

    // Get Screen width
    DisplayMetrics displaymetrics = new DisplayMetrics();
    this.getWindowManager().getDefaultDisplay().getMetrics(displaymetrics);
    float height = displaymetrics.heightPixels / 3;
    float width = displaymetrics.widthPixels / 3;

    int convertHeight = (int) hight, convertWidth = (int) width;

    // higher
    if (heightbmp > height) {
        convertHeight = (int) height - 20;
        bitmap = Bitmap.createScaledBitmap(bitmap, convertWidth,
                convertHighet, true);
    }

    // wider
    if (widthbmp > width) {
        convertWidth = (int) width - 20;
        bitmap = Bitmap.createScaledBitmap(bitmap, convertWidth,
                convertHeight, true);
    }

    return bitmap;
}

Answer 14

यद्यपि स्वीकृत उत्तर सही है, लेकिन यह Bitmapसमान पहलू अनुपात को ध्यान में रखते हुए आकार परिवर्तन नहीं करता है । यदि आप Bitmapउसी पहलू अनुपात को ध्यान में रखते हुए आकार बदलने के लिए एक विधि की तलाश कर रहे हैं, तो आप निम्नलिखित उपयोगिता फ़ंक्शन का उपयोग कर सकते हैं। फ़ंक्शन का उपयोग विवरण और स्पष्टीकरण इस लिंक पर मौजूद हैं ।

public static Bitmap resizeBitmap(Bitmap source, int maxLength) {
       try {
           if (source.getHeight() >= source.getWidth()) {
               int targetHeight = maxLength;
               if (source.getHeight() <= targetHeight) { // if image already smaller than the required height
                   return source;
               }

               double aspectRatio = (double) source.getWidth() / (double) source.getHeight();
               int targetWidth = (int) (targetHeight * aspectRatio);

               Bitmap result = Bitmap.createScaledBitmap(source, targetWidth, targetHeight, false);
               if (result != source) {
               }
               return result;
           } else {
               int targetWidth = maxLength;

               if (source.getWidth() <= targetWidth) { // if image already smaller than the required height
                   return source;
               }

               double aspectRatio = ((double) source.getHeight()) / ((double) source.getWidth());
               int targetHeight = (int) (targetWidth * aspectRatio);

               Bitmap result = Bitmap.createScaledBitmap(source, targetWidth, targetHeight, false);
               if (result != source) {
               }
               return result;

           }
       }
       catch (Exception e)
       {
           return source;
       }
   }

Answer 15

/**
 * Kotlin method for Bitmap scaling
 * @param bitmap the bitmap to be scaled
 * @param pixel  the target pixel size
 * @param width  the width
 * @param height the height
 * @param max    the max(height, width)
 * @return the scaled bitmap
 */
fun scaleBitmap(bitmap:Bitmap, pixel:Float, width:Int, height:Int, max:Int):Bitmap {
    val scale = px / max
    val h = Math.round(scale * height)
    val w = Math.round(scale * width)
    return Bitmap.createScaledBitmap(bitmap, w, h, true)
  }

Answer 16

पहलू अनुपात रखते हुए,

  public Bitmap resizeBitmap(Bitmap source, int width,int height) {
    if(source.getHeight() == height && source.getWidth() == width) return source;
    int maxLength=Math.min(width,height);
    try {
        source=source.copy(source.getConfig(),true);
        if (source.getHeight() <= source.getWidth()) {
            if (source.getHeight() <= maxLength) { // if image already smaller than the required height
                return source;
            }

            double aspectRatio = (double) source.getWidth() / (double) source.getHeight();
            int targetWidth = (int) (maxLength * aspectRatio);

            return Bitmap.createScaledBitmap(source, targetWidth, maxLength, false);
        } else {

            if (source.getWidth() <= maxLength) { // if image already smaller than the required height
                return source;
            }

            double aspectRatio = ((double) source.getHeight()) / ((double) source.getWidth());
            int targetHeight = (int) (maxLength * aspectRatio);

            return Bitmap.createScaledBitmap(source, maxLength, targetHeight, false);

        }
    }
    catch (Exception e)
    {
        return source;
    }
}