Công thức px đến dp, dp sang px android

Tôi đang cố gắng tính toán một lượng pixel thay đổi theo mật độ pixel độc lập và ngược lại.

Công thức (px to dp): dp = (int)(px / (displayMetrics.densityDpi / 160));này không hoạt động trên các thiết bị nhỏ vì nó được chia cho số không.

Đây là công thức dp to px của tôi:

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

Ai đó có thể cho tôi một số gợi ý?

Lưu ý: Giải pháp được sử dụng rộng rãi ở trên dựa trên displayMetrics.density. Tuy nhiên, các tài liệu giải thích rằng giá trị này là giá trị làm tròn, được sử dụng với màn hình 'xô'. Ví dụ. trên Nexus 10 của tôi, nó trả về 2, trong đó giá trị thực sẽ là 298dpi (thực) / 160dpi (mặc định) = 1.8625.

Tùy thuộc vào yêu cầu của bạn, bạn có thể cần chuyển đổi chính xác, có thể đạt được như thế này:

[Chỉnh sửa] Điều này không có nghĩa là được trộn lẫn với đơn vị dp nội bộ của Android, vì điều này tất nhiên vẫn dựa trên các xô màn hình. Sử dụng điều này khi bạn muốn một đơn vị sẽ hiển thị cùng kích thước thực trên các thiết bị khác nhau.

Chuyển đổi dp thành pixel:

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

Chuyển đổi pixel sang dp:

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

Lưu ý rằng có các thuộc tính xdpi và ydpi, bạn có thể muốn phân biệt, nhưng tôi không thể tưởng tượng một màn hình lành mạnh trong đó các giá trị này khác nhau rất nhiều.

Tôi đã giải quyết vấn đề của mình bằng cách sử dụng các công thức sau. Có thể những người khác được hưởng lợi từ nó.

dp đến px:

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

px đến dp:

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

px đến dp:

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

Cách hiệu quả

DP sang Pixel:

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

Pixel đến DP:

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

Hy vọng điều này sẽ giúp bạn.

Chỉ cần gọi getResources().getDimensionPixelSize(R.dimen.your_dimension)để chuyển đổi từ dpđơn vị sang pixel

Sử dụng chức năng này

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

px = dp * (dpi / 160)

dp = px * (160 / dpi)

Trong hầu hết các trường hợp, các hàm chuyển đổi được gọi thường xuyên. Chúng ta có thể tối ưu hóa nó bằng cách thêm ghi nhớ. Vì vậy, nó không tính toán mỗi lần hàm được gọi.

Hãy khai báo HashMap sẽ lưu trữ các giá trị được tính toán.

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

Một hàm tính toán các giá trị pixel:

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

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

    }

Hàm ghi nhớ trả về giá trị từ HashMap và duy trì bản ghi các giá trị trước đó.

Ghi nhớ có thể được thực hiện theo các cách khác nhau trong Java. Đối với 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 hỗ trợ chức năng Lambda :

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

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

Cảm ơn.

hãy thử http://labs.skinkers.com/content/android_dp_px_calculator/

Dưới đây funtions hoạt động tốt cho tôi trên các thiết bị.

Nó được lấy từ 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);
}

Bạn có thể sử dụng [DisplayMatrics][1]và xác định mật độ màn hình. Một cái gì đó như thế này:

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

Theo tôi nhớ, tốt hơn là sử dụng sàn để bù đắp và làm tròn cho chiều rộng.

Nếu bạn đang tìm kiếm một máy tính trực tuyến để chuyển đổi DP, SP, inch, milimet, điểm hoặc pixel sang và từ nhau ở các mật độ màn hình khác nhau, thì đây là công cụ đầy đủ nhất mà tôi biết .

// để nhận được về số thập phân / 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));

}

Kể từ khi bắt đầu

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

Sử dụng các tiện ích mở rộng Kotlin này:

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

Hãy sử dụng phương pháp này tôi đã viết:

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

Câu trả lời được chấp nhận ở trên là không hoàn toàn chính xác. Theo thông tin có được bằng cách kiểm tra mã nguồn Android:

Resources.getDimension()và getDimensionPixelOffset()/ getDimensionPixelSize()chỉ khác nhau ở chỗ cái trước trả về floattrong khi hai cái sau trả về cùng một giá trị được làm tròn thành intthích hợp. Đối với tất cả chúng, giá trị trả về được tính bằng pixel thô.

Tất cả ba chức năng là implementedy bằng cách gọi Resources.getValue()và chuyển đổi do đó thu được TypedValuebằng cách gọi TypedValue.complexToDimension(), TypedValue.complexToDimensionPixelOffset()vàTypedValue.complexToDimensionPixelSize() , tương ứng.

Do đó, nếu bạn muốn có được giá trị "thô" cùng với đơn vị được chỉ định trong nguồn XML, hãy gọi Resources.getValue()và sử dụng các phương thức của TypedValuelớp.

với sự giúp đỡ của các câu trả lời khác, tôi đã viết chức năng này.

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

Đây là một cách khác để làm điều đó bằng cách sử dụng các phần mở rộng 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)

và sau đó nó có thể được sử dụng như thế này từ bất cứ đâu

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

    }

biến thể trên câu trả lời ct_robs ở trên, nếu bạn đang sử dụng số nguyên, không chỉ tránh chia cho 0, nó còn tạo ra kết quả có thể sử dụng trên các thiết bị nhỏ:

trong các phép tính số nguyên liên quan đến phép chia cho độ chính xác lớn nhất nhân trước tiên trước khi chia để giảm hiệu ứng cắt ngắn.

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

5 * 120 = 600 / 160 = 3

thay vì

5 * (120 / 160 = 0) = 0

nếu bạn muốn kết quả tròn làm điều này

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

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