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



pixel resolution dpi (23)

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

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

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

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

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


dp to px कनवर्ट करने के dp to px यह कोड सहायक हो सकता है:

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

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

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

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

यह मेरे लिए काम करता है (सी #):

int pixels = (int)((dp) * Resources.System.DisplayMetrics.Density + 0.5f);

एंड्रॉइड डेवलपमेंट गाइड के मुताबिक:

px = dp * (dpi / 160)

लेकिन अक्सर आप पिक्सल में बताए गए डिज़ाइन को प्राप्त करते समय इसे अन्य तरीके से करना चाहते हैं। इसलिए:

dp = px / (dpi / 160)

यदि आप 240 डीपीआई डिवाइस पर हैं तो यह अनुपात 1.5 है (जैसा कि पहले बताया गया है), तो इसका मतलब है कि 60px आइकन एप्लिकेशन में 40 डीपी के बराबर है।


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

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

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


डीपी को पिक्सेल में कनवर्ट करने के लिए।
public static int dp2px(Resources resource, int dp) {
    return (int) TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_DIP,   dp,resource.getDisplayMetrics());
}
पिक्सेल को डीपी में कनवर्ट करने के लिए।
  public static float px2dp(Resources resource, float px)  {
    return (float) TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_PX, px,resource.getDisplayMetrics());
}

जहां संसाधन संदर्भ है .getResources ()।


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 परिवर्तित करता हूं।


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

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


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

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

आपको डीपी का उपयोग करना चाहिए जैसे आप पिक्सल करेंगे। वे सब कुछ हैं; स्वतंत्र पिक्सल प्रदर्शित करें। एक मध्यम घनत्व स्क्रीन पर आप वही संख्याओं का उपयोग करें, और आकार उच्च घनत्व स्क्रीन पर जादुई रूप से सही होगा।

हालांकि, ऐसा लगता है कि आपको अपने लेआउट डिज़ाइन में fill_parent विकल्प की आवश्यकता है। जब आप अपने व्यू या नियंत्रण को मूल कंटेनर में शेष शेष आकार में विस्तारित करना चाहते हैं तो fill_parent का उपयोग करें।


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

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

यदि आप एक प्रदर्शन महत्वपूर्ण अनुप्रयोग विकसित करते हैं, तो कृपया निम्नलिखित अनुकूलित वर्ग पर विचार करें:

public final class DimensionUtils {

    private static boolean isInitialised = false;
    private static float pixelsPerOneDp;

    // Suppress default constructor for noninstantiability.
    private DimensionUtils() {
        throw new AssertionError();
    }

    private static void initialise(View view) {
        pixelsPerOneDp = view.getResources().getDisplayMetrics().densityDpi / 160f;
        isInitialised = true;
    }

    public static float pxToDp(View view, float px) {
        if (!isInitialised) {
            initialise(view);
        }

        return px / pixelsPerOneDp;
    }

    public static float dpToPx(View view, float dp) {
        if (!isInitialised) {
            initialise(view);
        }

        return dp * pixelsPerOneDp;
    }
}

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

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

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

getDimension(int resourceId) 

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

getDimensionPixelSize(int resourceId)

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

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


पिक्सल को डीपी में परिवर्तित करने के लिए 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());

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


अधिमानतः 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;
}


DP to Pixel

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

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

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

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

यह क्रियान्वयन स्पेसिंग चार्ट के सही स्थान को सुनिश्चित करता है, भले ही उपयोगकर्ता मध्य-स्ट्रिंग को संपादित करता हो। सॉफ्ट कीबोर्ड (जैसे डैश) पर दिखाई देने वाले अन्य वर्ण भी समर्थित हैं; अर्थात्, उपयोगकर्ता उन्हें दर्ज नहीं कर सकता। एक सुधार जो किया जा सकता है: यह कार्यान्वयन वर्णों के मध्य-स्ट्रिंग को हटाने के लिए अनुमति नहीं देता है।

public class CreditCardTextWatcher implements TextWatcher {

    public static final char SPACING_CHAR = '-'; // Using a Unicode character seems to stuff the logic up.

    @Override
    public void beforeTextChanged(final CharSequence s, final int start, final int count, final int after) { }

    @Override
    public void onTextChanged(final CharSequence s, final int start, final int before, final int count) { }

    @Override
    public void afterTextChanged(final Editable s) {
        if (s.length() > 0) {

            // Any changes we make to s in here will cause this method to be run again.  Thus we only make changes where they need to be made,
            // otherwise we'll be in an infinite loop.

            // Delete any spacing characters that are out of place.
            for (int i=s.length()-1; i>=0; --i) {
                if (s.charAt(i) == SPACING_CHAR  // There is a spacing char at this position ,
                        && (i+1 == s.length()    // And it's either the last digit in the string (bad),
                        || (i+1) % 5 != 0)) {    // Or the position is not meant to contain a spacing char?

                    s.delete(i,i+1);
                }
            }

            // Insert any spacing characters that are missing.
            for (int i=14; i>=4; i-=5) {
                if (i < s.length() && s.charAt(i) != SPACING_CHAR) {
                    s.insert(i, String.valueOf(SPACING_CHAR));
                }
            }
        }
    }
}

CC डिजिट को मास्क करने के लिए एक उपयुक्त PasswordTransformationMethod कार्यान्वयन के साथ अच्छी तरह से काम करता है।





android pixel resolution dpi