Formula piksel dp, dp piksel android için

Ben yoğunluk bağımsız piksel ve tersi için piksel değişken bir miktar hesaplamak için çalışıyorum.

Bu formül (px to dp): dp = (int)(px / (displayMetrics.densityDpi / 160));, sıfıra bölündüğü için küçük cihazlarda çalışmaz.

Bu benim dp piksel formülü:

px = (int)(dp * (displayMetrics.densityDpi / 160));

Birisi bana bazı işaretçiler verebilir mi?

Not: Yukarıda yaygın olarak kullanılan çözüm esas alınmıştır displayMetrics.density. Ancak dokümanlar bu değerin, ekran 'kovaları' ile kullanılan yuvarlatılmış bir değer olduğunu açıklar. Örneğin. Nexus 10'umda gerçek değer 298dpi (gerçek) / 160dpi (varsayılan) = 1.8625 olacak şekilde 2 değerini döndürür.

Gereksinimlerinize bağlı olarak, aşağıdaki gibi gerçekleştirilebilecek kesin dönüşüme ihtiyacınız olabilir:

[Düzenle] Bu, elbette hala ekran kovalarına dayandığından, Android'in dahili dp birimi ile karıştırılması amaçlanmamıştır. Bunu, farklı cihazlarda aynı gerçek boyutu işlemesi gereken bir birimin olmasını istediğiniz yerde kullanın.

DP'yi piksele dönüştür:

public int dpToPx(int dp) {
    DisplayMetrics displayMetrics = getContext().getResources().getDisplayMetrics();
    return Math.round(dp * (displayMetrics.xdpi / DisplayMetrics.DENSITY_DEFAULT));     
}

Piksel dönüştürmek dp:

public int pxToDp(int px) {
    DisplayMetrics displayMetrics = getContext().getResources().getDisplayMetrics();
    return Math.round(px / (displayMetrics.xdpi / DisplayMetrics.DENSITY_DEFAULT));
}

Xdpi ve ydpi özellikleri olduğunu unutmayın, ayırt etmek isteyebilirsiniz, ancak bu değerlerin büyük ölçüde farklı olduğu bir aklı başında ekran hayal edemiyorum.

Sorunumu aşağıdaki formülleri kullanarak çözdüm. Diğer insanlar bundan faydalansın.

dp piksel için:

displayMetrics = context.getResources().getDisplayMetrics();
return (int)((dp * displayMetrics.density) + 0.5);

pikselden dp'ye:

displayMetrics = context.getResources().getDisplayMetrics();
return (int) ((px/displayMetrics.density)+0.5);

pikselden dp'ye:

int valueInpx = ...;
int valueInDp= (int) TypedValue.applyDimension(
            TypedValue.COMPLEX_UNIT_DIP, valueInpx , getResources()
                .getDisplayMetrics());

Şimdiye kadar verimli yol

DP - Piksel arası:

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

Pikselden DP'ye:

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

Umarım bu size yardımcı olacaktır.

Birimlerden piksellere getResources().getDimensionPixelSize(R.dimen.your_dimension)dönüştürmek için arayındp

Bu işlevi kullan

private int dp2px(int dp) {
    return (int) TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_DIP, dp, getResources().getDisplayMetrics());
}

px = dp * (dpi / 160)

dp = px * (160 / dpi)

Çoğu durumda, dönüştürme işlevleri sık sık çağrılır. Not ekleyerek optimize edebiliriz. Bu nedenle, işlev her çağrıldığında hesaplanmaz.

Hesaplanan değerleri depolayacak bir HashMap beyan edelim.

private static Map<Float, Float> pxCache = new HashMap<>();

Piksel değerlerini hesaplayan bir işlev:

public static float calculateDpToPixel(float dp, Context context) {

        Resources resources = context.getResources();
        DisplayMetrics metrics = resources.getDisplayMetrics();
        float px = dp * (metrics.densityDpi / 160f);
        return px;

    }

HashMap'ten değeri döndüren ve önceki değerlerin kaydını tutan bir not işlevi.

Notlama, Java'da farklı şekillerde uygulanabilir. Java 7 için :

public static float convertDpToPixel(float dp, final Context context) {

        Float f = pxCache.get(dp);
        if (f == null) {
            synchronized (pxCache) {
                f = calculateDpToPixel(dp, context);
                pxCache.put(dp, f);
            }

        }

        return f;
    }

Java 8 Lambda işlevini destekler :

public static float convertDpToPixel(float dp, final Context context) {

        pxCache.computeIfAbsent(dp, y ->calculateDpToPixel(dp,context));
}

Teşekkürler.

bunu deneyin http://labs.skinkers.com/content/android_dp_px_calculator/

Aşağıdaki işlevler cihazlar arasında benim için iyi çalıştı.

Https://gist.github.com/laaptu/7867851 adresinden alınır.

public static float convertPixelsToDp(float px){
    DisplayMetrics metrics = Resources.getSystem().getDisplayMetrics();
    float dp = px / (metrics.densityDpi / 160f);
    return Math.round(dp);
}

public static float convertDpToPixel(float dp){
    DisplayMetrics metrics = Resources.getSystem().getDisplayMetrics();
    float px = dp * (metrics.densityDpi / 160f);
    return Math.round(px);
}

[DisplayMatrics][1]Ekran yoğunluğunu kullanabilir ve belirleyebilirsiniz. Bunun gibi bir şey:

int pixelsValue = 5; // margin in pixels
float d = context.getResources().getDisplayMetrics().density;
int margin = (int)(pixelsValue * d);

Hatırladığım gibi, ofsetler için döşeme ve genişlikler için yuvarlama kullanmak daha iyidir.

DP, SP, inç, milimetre, nokta veya pikselleri farklı ekran yoğunluklarında birbirine dönüştürmek için çevrimiçi bir hesap makinesi arıyorsanız, bu bildiğim en eksiksiz araçtır .

// Ondalık / Kayan Nokta açısından almak için

public static float convertPixelsToDp(float px, Context context) {

    Resources resources = context.getResources();
    DisplayMetrics metrics = resources.getDisplayMetrics();
    float dp = px / (metrics.densityDpi / 160f);
    return Math.round(dp);
}



public static float convertDpToPixel(float dp, Context context) {
    DisplayMetrics metrics = Resources.getSystem().getDisplayMetrics();
    float px = dp * (metrics.densityDpi / 160f);
    return Math.round(px);
}


// for  getting in terms of Integer

private int convertPxToDp(int px, Context context) {
    Resources resources = context.getResources();
    return Math.round(px / (resources.getDisplayMetrics().xdpi / DisplayMetrics.DENSITY_DEFAULT));
}


private int convertDpToPx(int dp, Context context) {
    Resources resources = context.getResources();

    return Math.round(dp * (resources.getDisplayMetrics().xdpi / DisplayMetrics.DENSITY_DEFAULT));

}

________________________________________________________________________________

public static float convertPixelsToDp(float px){
    DisplayMetrics metrics = Resources.getSystem().getDisplayMetrics();
    float dp = px / (metrics.densityDpi / 160f);
    return Math.round(dp);
}

public static float convertDpToPixel(float dp){
    DisplayMetrics metrics = Resources.getSystem().getDisplayMetrics();
    float px = dp * (metrics.densityDpi / 160f);
    return Math.round(px);
}


private int convertDpToPx(int dp){
    return Math.round(dp*(getResources().getDisplayMetrics().xdpi/DisplayMetrics.DENSITY_DEFAULT));

}

private int convertPxToDp(int px){
    return Math.round(px/(Resources.getSystem().getDisplayMetrics().xdpi/DisplayMetrics.DENSITY_DEFAULT));
}

Şu Kotlin uzantılarını kullanın:

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

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

Yazdığım bu yöntemi kullanmaktan çekinmeyin:

int dpToPx(int dp)
{
    return (int) (dp * getResources().getDisplayMetrics().density + 0.5f);
}

Yukarıda kabul edilen cevap tam olarak doğru değildir. Android kaynak kodunu inceleyerek elde edilen bilgilere göre:

Resources.getDimension()ve getDimensionPixelOffset()/ getDimensionPixelSize()ancak sadece birincisi geri floatdönerken, ikincisi intuygun değere yuvarlanmış aynı değeri döndürür . Hepsi için, dönüş değeri ham piksel cinsindendir.

Tüm üç fonksiyon arayarak implementedy olan Resources.getValue()ve bu şekilde dönüştürerek elde TypedValuearayarak TypedValue.complexToDimension(), TypedValue.complexToDimensionPixelOffset()ve TypedValue.complexToDimensionPixelSize()sırasıyla.

Bu nedenle, XML kaynağında belirtilen birim ile birlikte "raw" değerini elde etmek istiyorsanız Resources.getValue(), TypedValuesınıfın yöntemlerini çağırın ve kullanın .

diğer cevapların yardımıyla bu fonksiyonu yazdım.

public static int convertToPixels(Context context, int nDP)
{
        final float conversionScale = context.getResources().getDisplayMetrics().density; 
        return (int) ((nDP * conversionScale) + 0.5f) ;
}

İşte kotlin uzantılarını kullanarak yapmanın başka bir yolu:

val Int.dpToPx: Int
    get() = Math.round(this * Resources.getSystem().displayMetrics.density)

val Int.pxToDp: Int
    get() = Math.round(this / Resources.getSystem().displayMetrics.density)

ve sonra her yerden böyle kullanılabilir

12.dpToPx

244.pxToDp

DisplayMetrics displayMetrics = contaxt.getResources()
            .getDisplayMetrics();

    int densityDpi = (int) (displayMetrics.density * 160f);
    int ratio = (densityDpi / DisplayMetrics.DENSITY_DEFAULT);
    int px;
    if (ratio == 0) {
        px = dp;
    } else {
        px = Math.round(dp * ratio);

    }

Yukarıdaki ct_robs cevabı varyasyonu, eğer tamsayı kullanıyorsanız, sadece 0'a bölünmeyi önlemekle kalmaz, aynı zamanda küçük cihazlarda da kullanılabilir bir sonuç verir:

tamsayı hesaplamalarında, en yüksek hassasiyet için bölmeyi içeren, kesme etkilerini azaltmak için bölmeden önce çarpın.

px = dp * dpi / 160
dp = px * 160 / dpi

5 * 120 = 600 / 160 = 3

onun yerine

5 * (120 / 160 = 0) = 0

yuvarlak sonuç istiyorsanız bunu yapın

px = (10 * dp * dpi / 160 + 5) / 10
dp = (10 * px * 160 / dpi + 5) / 10

10 * 5 * 120 = 6000 / 160 = 37 + 5 = 42 / 10 = 4