Formula px ke dp, dp ke px android

Saya mencoba menghitung jumlah variabel piksel ke piksel independen dan sebaliknya.

Formula (px to dp): dp = (int)(px / (displayMetrics.densityDpi / 160));ini tidak berfungsi pada perangkat kecil karena dibagi dengan nol.

Ini adalah formula dp to px saya:

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

Bisakah seseorang memberi saya beberapa petunjuk?

Catatan: Solusi yang banyak digunakan di atas didasarkan pada displayMetrics.density. Namun, dokumen menjelaskan bahwa nilai ini adalah nilai bulat, digunakan dengan layar 'ember'. Misalnya. pada Nexus 10 saya mengembalikan 2, di mana nilai sebenarnya adalah 298dpi (real) / 160dpi (default) = 1.8625.

Tergantung pada kebutuhan Anda, Anda mungkin memerlukan transformasi yang tepat, yang dapat dicapai seperti ini:

[Sunting] Ini tidak dimaksudkan untuk dicampur dengan unit dp internal Android, karena hal ini tentu saja masih berdasarkan pada ember layar. Gunakan ini di mana Anda menginginkan unit yang harus merender ukuran sebenarnya yang sama pada perangkat yang berbeda.

Konversi dp ke piksel:

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

Konversikan piksel ke dp:

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

Perhatikan bahwa ada properti xdpi dan ydpi, Anda mungkin ingin membedakan, tapi saya tidak bisa membayangkan tampilan waras di mana nilai-nilai ini sangat berbeda.

Saya memecahkan masalah saya dengan menggunakan rumus berikut. Semoga orang lain mendapat manfaat darinya.

dp ke px:

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

px ke dp:

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

px ke dp:

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

Cara yang efisien

DP ke Pixel:

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

Piksel ke DP:

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

Semoga ini bisa membantu Anda.

Panggil saja getResources().getDimensionPixelSize(R.dimen.your_dimension)untuk mengonversi dari dpsatuan ke piksel

Gunakan fungsi ini

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

px = dp * (dpi / 160)

dp = px * (160 / dpi)

Dalam sebagian besar kasus, fungsi konversi sering dipanggil. Kami dapat mengoptimalkannya dengan menambahkan memoisasi. Jadi, itu tidak menghitung setiap kali fungsi dipanggil.

Mari mendeklarasikan HashMap yang akan menyimpan nilai yang dihitung.

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

Fungsi yang menghitung nilai piksel:

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

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

    }

Fungsi memoisasi yang mengembalikan nilai dari HashMap dan memelihara catatan nilai sebelumnya.

Memoisasi dapat diimplementasikan dengan berbagai cara di Jawa. Untuk Java 7 :

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 mendukung fungsi Lambda :

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

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

Terima kasih.

coba ini http://labs.skinkers.com/content/android_dp_px_calculator/

Fungsi di bawah berfungsi dengan baik untuk saya di seluruh perangkat.

Ini diambil dari https://gist.github.com/laaptu/7867851

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

Anda dapat menggunakan [DisplayMatrics][1]dan menentukan kepadatan layar. Sesuatu seperti ini:

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

Seingat saya lebih baik menggunakan lantai untuk offset dan pembulatan untuk lebar.

Jika Anda mencari kalkulator daring untuk mengonversi DP, SP, inci, milimeter, titik atau piksel ke dan dari satu sama lain pada kepadatan layar yang berbeda, ini adalah alat paling lengkap yang saya tahu .

// untuk mendapatkan dalam bentuk Desimal / Float

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

Gunakan ekstensi Kotlin ini:

/**
 * 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()

Jangan ragu untuk menggunakan metode ini yang saya tulis:

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

Jawaban yang diterima di atas tidak sepenuhnya akurat. Menurut informasi yang diperoleh dengan memeriksa kode sumber Android:

Resources.getDimension()dan getDimensionPixelOffset()/ getDimensionPixelSize()hanya berbeda dalam hal pengembalian yang pertama floatsedangkan yang kedua mengembalikan nilai yang sama dibulatkan menjadi inttepat. Untuk semuanya, nilai kembaliannya dalam piksel mentah.

Ketiga fungsi diimplementasikan dengan memanggil Resources.getValue()dan mengkonversi sehingga diperoleh TypedValuedengan memanggil TypedValue.complexToDimension(), TypedValue.complexToDimensionPixelOffset()dan TypedValue.complexToDimensionPixelSize(), masing-masing.

Oleh karena itu, jika Anda ingin mendapatkan nilai "mentah" bersama dengan unit yang ditentukan dalam sumber XML, panggil Resources.getValue()dan gunakan metode TypedValuekelas.

dengan bantuan jawaban lain saya menulis fungsi ini.

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

Berikut cara lain untuk melakukannya menggunakan ekstensi kotlin:

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

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

dan kemudian dapat digunakan seperti ini dari mana saja

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

    }

variasi jawaban ct_robs di atas, jika Anda menggunakan bilangan bulat, yang tidak hanya menghindari bagi dengan 0, juga menghasilkan hasil yang dapat digunakan pada perangkat kecil:

dalam perhitungan bilangan bulat yang melibatkan pembagian untuk penggandaan presisi terbesar terlebih dahulu sebelum membaginya untuk mengurangi efek pemotongan.

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

5 * 120 = 600 / 160 = 3

dari pada

5 * (120 / 160 = 0) = 0

jika Anda ingin hasil bulat lakukan ini

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

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