[android] पिक्सल को डीपी में कनवर्ट करना



12 Answers

/**
 * This method converts dp unit to equivalent pixels, depending on device density. 
 * 
 * @param dp A value in dp (density independent pixels) unit. Which we need to convert into pixels
 * @param context Context to get resources and device specific display metrics
 * @return A float value to represent px equivalent to dp depending on device density
 */
public static float convertDpToPixel(float dp, Context context){
    Resources resources = context.getResources();
    DisplayMetrics metrics = resources.getDisplayMetrics();
    float px = dp * ((float)metrics.densityDpi / DisplayMetrics.DENSITY_DEFAULT);
    return px;
}

/**
 * This method converts device specific pixels to density independent pixels.
 * 
 * @param px A value in px (pixels) unit. Which we need to convert into db
 * @param context Context to get resources and device specific display metrics
 * @return A float value to represent dp equivalent to px value
 */
public static float convertPixelsToDp(float px, Context context){
    Resources resources = context.getResources();
    DisplayMetrics metrics = resources.getDisplayMetrics();
    float dp = px / ((float)metrics.densityDpi / DisplayMetrics.DENSITY_DEFAULT);
    return dp;
}
Question

मैंने अपने एप्लिकेशन को पेंटेक डिवाइस के लिए पिक्सल में दी गई ऊंचाई और चौड़ाई के साथ बनाया है जिसका संकल्प 480x800 है।

मुझे एक जी 1 डिवाइस के लिए ऊंचाई और चौड़ाई को बदलने की जरूरत है। मैंने सोचा कि इसे डीपी में परिवर्तित करने से समस्या हल हो जाएगी और दोनों उपकरणों के लिए एक ही समाधान प्रदान किया जाएगा।

पिक्सेल को डीपी में बदलने का कोई आसान तरीका है? कोई सुझाव?




यदि आपके पास मान / आयाम के अंदर आयाम है तो शायद सबसे अच्छा तरीका यह है कि आयाम सीधे प्राप्त करें () विधि से आयाम प्राप्त करने के लिए, यह आपको पहले से ही पिक्सेल मान में परिवर्तित आयाम वापस कर देगा।

context.getResources().getDimension(R.dimen.my_dimension)

बस बेहतर व्याख्या करने के लिए,

getDimension(int resourceId) 

पहले से ही पिक्सेल एएस ए फ्लोट में परिवर्तित आयाम वापस कर देगा।

getDimensionPixelSize(int resourceId)

वही वापस कर देगा लेकिन int को छोटा कर दिया जाएगा, इसलिए एक इंटेग्रर के रूप में।

एंड्रॉइड संदर्भ देखें




इस तरह यह मेरे लिए काम करता है:

DisplayMetrics displaymetrics = new DisplayMetrics();
getWindowManager().getDefaultDisplay().getMetrics(displaymetrics);
int  h = displaymetrics.heightPixels;
float  d = displaymetrics.density;
int heightInPixels=(int) (h/d);

आप चौड़ाई के लिए भी ऐसा कर सकते हैं।




यह आपको रूपांतरण डीपी को पिक्सेल में देना चाहिए:

public static int dpToPx(Context context, int dp) {
       final float scale = context.getResources().getDisplayMetrics().density;
       return (int) (dp * scale + 0.5f);
    }

यह आपको रूपांतरण पिक्सल को डीपी में देना चाहिए:

 public static int pxToDp(int px) { return (int) (px / Resources.getSystem().getDisplayMetrics().density); } ); 



इसलिए आप डीपी में निर्दिष्ट आयाम से सही मात्रा में पिक्सल की गणना करने के लिए निम्न फॉर्मूलेटर का उपयोग कर सकते हैं

public int convertToPx(int dp) {
    // Get the screen's density scale
    final float scale = getResources().getDisplayMetrics().density;
    // Convert the dps to pixels, based on density scale
    return (int) (dp * scale + 0.5f);
}



इस तरह:

public class ScreenUtils {

    public static float dpToPx(Context context, float dp) {
        if (context == null) {
            return -1;
        }
        return dp * context.getResources().getDisplayMetrics().density;
    }

    public static float pxToDp(Context context, float px) {
        if (context == null) {
            return -1;
        }
        return px / context.getResources().getDisplayMetrics().density;
    }
}

संदर्भ पर निर्भर, फ्लोट मूल्य वापसी, स्थैतिक विधि

से: https://github.com/Trinea/android-common/blob/master/src/cn/trinea/android/common/util/ScreenUtils.java#L15




पिक्सल को डीपी में परिवर्तित करने के लिए http://developer.android.com/reference/android/util/TypedValue.html गए http://developer.android.com/reference/android/util/TypedValue.html उपयोग करें।

जैसा कि दस्तावेज उल्लेख किया गया है: गतिशील रूप से टाइप किए गए डेटा मान के लिए कंटेनर।

और applyDimension विधि का उपयोग करें:

public static float applyDimension (int unit, float value, DisplayMetrics metrics) 

जो एक अनपॅक किए गए जटिल डेटा मान को अपने अंतिम फ़्लोटिंग पॉइंट मान में निम्न आयाम में परिवर्तित करता है:

Resources resource = getResources();
float dp = TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_PX, 69, resource.getDisplayMetrics());

उम्मीद है की वो मदद करदे ।




यदि आप आयाम एक्सएमएल का उपयोग कर सकते हैं तो यह बहुत आसान है!

आपके res/values/dimens.xml :

<?xml version="1.0" encoding="utf-8"?>
<resources>
    <dimen name="thumbnail_height">120dp</dimen>
    ...
    ...
</resources>

फिर अपने जावा में:

getResources().getDimensionPixelSize(R.dimen.thumbnail_height);



कोटलिन का उपयोग करने वाले किसी के लिए:

val Int.toPx: Int
    get() = (this * Resources.getSystem().displayMetrics.density).toInt()

val Int.toDp: Int
    get() = (this / Resources.getSystem().displayMetrics.density).toInt()

उपयोग:

64.toPx
32.toDp



ऊपर बहुत सारे महान समाधान। हालांकि, मैंने पाया सबसे अच्छा समाधान गूगल का डिज़ाइन है:

https://design.google.com/devices/




यदि आप इंटीजर मान चाहते हैं तो Math.round () का उपयोग करके फ्लोट को निकटतम पूर्णांक में ले जाएगा।

public static int pxFromDp(final float dp) {
        return Math.round(dp * Resources.getSystem().getDisplayMetrics().density);
    }



आप इसका उपयोग कर सकते हैं .. संदर्भ के बिना

public static int pxToDp(int px) {
    return (int) (px / Resources.getSystem().getDisplayMetrics().density);
}

public static int dpToPx(int dp) {
    return (int) (dp * Resources.getSystem().getDisplayMetrics().density);
}



float density = context.getResources().getDisplayMetrics().density;
float px = someDpValue * density;
float dp = somePxValue / density;

density बराबर है

  • .75 पर .75 ( 120 डीपीआई)
  • 1.0 mdpi पर ( 160 डीपीआई; बेसलाइन)
  • hdpi पर 1.5 ( 240 डीपीआई)
  • 2.0 xhdpi पर ( 320 डीपीआई)
  • 3.0 xxhdpi पर ( 480 डीपीआई)
  • 4.0 xxxhdpi पर ( 640 डीपीआई)

डीपीआई मूल्यों के साथ खेलने के लिए इस ऑनलाइन कनवर्टर का प्रयोग करें।

संपादित करें: ऐसा लगता है कि dpi बाल्टी और density बीच कोई 1: 1 संबंध नहीं है। ऐसा लगता है कि Nexus 5X xxhdpi का density मान 2.625 ( 3 बजाय) है। डिवाइस मेट्रिक्स में अपने लिए देखें।




Related