Mengonversi piksel ke dp

Saya telah membuat aplikasi saya dengan tinggi dan lebar yang diberikan dalam piksel untuk perangkat Pantech yang resolusinya 480x800.

Saya perlu mengonversi tinggi dan lebar untuk perangkat G1.
Saya pikir mengubahnya menjadi dp akan menyelesaikan masalah dan memberikan solusi yang sama untuk kedua perangkat.

Apakah ada cara mudah untuk mengonversi piksel ke dp?
Ada saran?

// Converts 14 dip into its equivalent px
float dip = 14f;
Resources r = getResources();
float px = TypedValue.applyDimension(
    TypedValue.COMPLEX_UNIT_DIP,
    dip,
    r.getDisplayMetrics()
);

/**
 * 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){
    return dp * ((float) context.getResources().getDisplayMetrics().densityDpi / DisplayMetrics.DENSITY_DEFAULT);
}

/**
 * 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){
    return px / ((float) context.getResources().getDisplayMetrics().densityDpi / DisplayMetrics.DENSITY_DEFAULT);
}

Lebih disukai dimasukkan ke dalam kelas 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;
}

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

density sama dengan

• .75pada ldpi( 120dpi)
• 1.0pada mdpi( 160dpi; garis dasar)
• 1.5pada hdpi(240 dpi)
• 2.0pada xhdpi( 320dpi)
• 3.0pada xxhdpi( 480dpi)
• 4.0pada xxxhdpi( 640dpi)

Gunakan konverter online ini untuk bermain-main dengan nilai dpi.

EDIT: Tampaknya tidak ada hubungan 1: 1 antara dpibucket dan density. Sepertinya Nexus 5Xmakhluk xxhdpimemiliki densitynilai 2.625(bukan 3). Lihat sendiri di Metrik Perangkat .

Anda dapat menggunakan ini .. tanpa Konteks

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

Seperti @Stan disebutkan .. menggunakan pendekatan ini dapat menyebabkan masalah jika sistem mengubah kepadatan. Jadi sadarilah itu!

Secara pribadi saya menggunakan Konteks untuk melakukan itu. Ini hanya pendekatan lain yang ingin saya bagikan kepada Anda

Jika Anda dapat menggunakan dimensi XML, itu sangat sederhana!

Di Anda res/values/dimens.xml:

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

Kemudian di Jawa Anda:

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

Menurut Panduan Pengembangan Android:

px = dp * (dpi / 160)

Tetapi seringkali Anda ingin melakukan ini dengan cara sebaliknya ketika Anda menerima desain yang dinyatakan dalam piksel. Begitu:

dp = px / (dpi / 160)

Jika Anda menggunakan perangkat 240dpi, rasio ini adalah 1,5 (seperti yang dinyatakan sebelumnya), jadi ini berarti bahwa ikon 60px sama dengan 40dp dalam aplikasi.

Tanpa Context, metode statis yang elegan:

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

Untuk DP to Pixel

Buat nilai dalam dimens.xml

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

Dapatkan nilai itu pixelsebagai:

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

Karena itu Anda dapat menggunakan formulator berikut untuk menghitung jumlah piksel yang tepat dari dimensi yang ditentukan dalam dp

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

Untuk siapa saja yang menggunakan Kotlin:

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

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

Pemakaian:

64.toPx
32.toDp

Ada util default di SDK android: http://developer.android.com/reference/android/util/TypedValue.html

float resultPix = TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_DIP,1,getResources().getDisplayMetrics())

menggunakan kotlin-extension membuatnya lebih baik

fun Int.toPx(context: Context): Int = (this * context.resources.displayMetrics.density).toInt()

fun Int.toDp(context: Context): Int = (this / context.resources.displayMetrics.density).toInt()

MEMPERBARUI:

Karena displayMetricsmerupakan bagian dari Sumber Daya bersama global , kita dapat menggunakanResources.getSystem()

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

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

Ini akan memberi Anda konversi dp ke piksel:

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

Ini akan memberi Anda piksel konversi ke dp:

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

Kotlin

fun convertDpToPixel(dp: Float, context: Context): Float {
    return dp * (context.resources.displayMetrics.densityDpi.toFloat() / DisplayMetrics.DENSITY_DEFAULT)
}

fun convertPixelsToDp(px: Float, context: Context): Float {
    return px / (context.resources.displayMetrics.densityDpi.toFloat() / DisplayMetrics.DENSITY_DEFAULT)
}

Jawa

public static float convertDpToPixel(float dp, Context context) {
    return dp * ((float) context.getResources().getDisplayMetrics().densityDpi / DisplayMetrics.DENSITY_DEFAULT);
}

public static float convertPixelsToDp(float px, Context context) {
    return px / ((float) context.getResources().getDisplayMetrics().densityDpi / DisplayMetrics.DENSITY_DEFAULT);
}

Mungkin cara terbaik jika Anda memiliki dimensi di dalam nilai / dimen adalah untuk mendapatkan dimensi langsung dari metode getDimension (), itu akan mengembalikan Anda dimensi yang sudah dikonversi menjadi nilai piksel.

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

Untuk lebih menjelaskan hal ini,

getDimension(int resourceId) 

akan mengembalikan dimensi yang sudah dikonversi ke piksel AS A FLOAT.

getDimensionPixelSize(int resourceId)

akan mengembalikan yang sama tetapi terpotong ke int, jadi AS AN INTEGER.

Lihat referensi Android

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

di mana sumber daya adalah context.getResources ().

seperti ini:

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

tergantung pada Konteks, mengembalikan nilai float, metode statis

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

Pendekatan yang lebih elegan menggunakan fungsi ekstensi kotlin

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

Pemakaian:

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

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

Jika Anda mengembangkan aplikasi penting kinerja, harap pertimbangkan kelas yang dioptimalkan berikut:

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

untuk mengonversi Pixel ke dp gunakan TypedValue .

Seperti yang disebutkan dalam dokumentasi: Wadah untuk nilai data yang diketik secara dinamis.

dan gunakan metode applyDimension :

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

yang Mengonversi nilai data kompleks yang tidak dibungkus yang menahan dimensi ke nilai titik apung terakhirnya seperti berikut:

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

Semoga Itu Membantu.

Ini cara kerjanya untuk saya:

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

Anda dapat melakukan hal yang sama untuk lebar.

Banyak solusi hebat di atas. Namun, solusi terbaik yang saya temukan adalah desain google:

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

Anda harus menggunakan dp seperti halnya piksel. Itu saja mereka; menampilkan piksel independen. Gunakan angka yang sama seperti pada layar kepadatan menengah, dan ukurannya akan benar secara ajaib pada layar kepadatan tinggi.

Namun, sepertinya yang Anda butuhkan adalah opsi fill_parent dalam desain tata letak Anda. Gunakan fill_parent ketika Anda ingin tampilan atau kontrol Anda diperluas ke semua ukuran yang tersisa di wadah induk.

PXdan DPberbeda tetapi serupa.

DPadalah resolusi ketika Anda hanya memperhitungkan ukuran fisik layar. Ketika Anda menggunakannya DPakan mengatur tata letak Anda ke layar berukuran serupa lainnya dengan pixelkepadatan berbeda .

Kadang-kadang Anda benar-benar ingin pixels, dan ketika Anda berurusan dengan dimensi dalam kode Anda selalu berurusan dengan nyata pixels, kecuali jika Anda mengubahnya.

Jadi pada perangkat android, hdpilayar berukuran normal , 800x480 is 533x320di DP(saya percaya). Untuk mengkonversi DPmenjadi pixels /1.5, untuk mengkonversi kembali *1.5. Ini hanya untuk satu ukuran layar dan dpi, itu akan berubah tergantung pada desain. Artis kami memberi saya pixelsdan saya beralih ke DPdengan 1.5persamaan di atas .

Jika Anda ingin nilai Integer maka menggunakan Math.round () akan mengitari float ke integer terdekat.

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

Jawaban terbaik datang dari kerangka kerja Android itu sendiri: cukup gunakan persamaan ini ...

public static int dpToPixels(final DisplayMetrics display_metrics, final float dps) {
    final float scale = display_metrics.density;
    return (int) (dps * scale + 0.5f);
}

(mengkonversi dp ke px)

Workds ini untuk saya (C #):

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

kotlin

   fun spToPx(ctx: Context, sp: Float): Float {
    return sp * ctx.resources.displayMetrics.scaledDensity
}

fun pxToDp(context: Context, px: Float): Float {
    return px / context.resources.displayMetrics.density
}

fun dpToPx(context: Context, dp: Float): Float {
    return dp * context.resources.displayMetrics.density
}

Jawa

   public static float spToPx(Context ctx,float sp){
    return sp * ctx.getResources().getDisplayMetrics().scaledDensity;
}

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

public static float dpToPx(final Context context, final float dp) {
    return dp * context.getResources().getDisplayMetrics().density;
}