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




pixel resolution (18)

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

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

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


अधिमानतः Util.java वर्ग में डाल दिया

public static float dpFromPx(final Context context, final float px) {
    return px / context.getResources().getDisplayMetrics().density;
}

public static float pxFromDp(final Context context, final float dp) {
    return dp * context.getResources().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);
}

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

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

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


इस तरह:

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


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

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



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

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

कोटलिन के विस्तार समारोह का उपयोग करके अधिक सुरुचिपूर्ण दृष्टिकोण

/**
 * Converts dp to pixel
 */
val Int.dpToPx: Int get() = (this * Resources.getSystem().displayMetrics.density).toInt()

/**
 * Converts pixel to dp
 */
val Int.pxToDp: Int get() = (this / Resources.getSystem().displayMetrics.density).toInt()

उपयोग:

println("16 dp in pixel: ${16.dpToPx}")
println("16 px in dp: ${16.pxToDp}")

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

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

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

आपके 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);

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

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

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

getDimension(int resourceId) 

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

getDimensionPixelSize(int resourceId)

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

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


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

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

Context बिना, सुरुचिपूर्ण स्थिर तरीकों:

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

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

PX और DP अलग हैं लेकिन समान हैं।

DP संकल्प है जब आप केवल स्क्रीन के भौतिक आकार को कारक बनाते हैं। जब आप DP उपयोग करते हैं तो यह आपके लेआउट को अन्य pixel घनत्व वाले अन्य समान आकार की स्क्रीन पर स्केल करेगा।

कभी-कभी आप वास्तव में pixels चाहते हैं, और जब आप कोड में आयामों से निपटते हैं तो आप हमेशा वास्तविक pixels से निपटते रहते हैं, जब तक कि आप उन्हें परिवर्तित नहीं करते।

तो एक एंड्रॉइड डिवाइस पर, सामान्य आकार 800x480 is 533x320 स्क्रीन, DP में 800x480 is 533x320 है (मुझे विश्वास है)। वापस *1.5 को बदलने के लिए DP को pixels /1.5 *1.5 परिवर्तित करने के लिए। यह केवल एक स्क्रीन आकार और dpi , यह डिजाइन के आधार पर बदल जाएगा। हमारे कलाकार मुझे pixels देते हैं और मैं ऊपर 1.5 समीकरण के साथ DP परिवर्तित करता हूं।


DP to Pixel

dimens.xml में एक मान बनाएँ

<dimen name="textSize">20dp</dimen>

उस मान को pixel में प्राप्त करें:

int sizeInPixel = context.getResources().getDimensionPixelSize(R.dimen.textSize);

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

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 बजाय) है। डिवाइस मेट्रिक्स में अपने लिए देखें।


float scaleValue = getContext().getResources().getDisplayMetrics().density;
int pixels = (int) (dps * scaleValue + 0.5f);




dpi