Chuyển đổi pixel sang dp

Tôi đã tạo ứng dụng của mình với chiều cao và chiều rộng được tính bằng pixel cho thiết bị Pantech có độ phân giải 480x800.

Tôi cần chuyển đổi chiều cao và chiều rộng cho thiết bị G1.
Tôi nghĩ chuyển đổi nó thành dp sẽ giải quyết vấn đề và cung cấp cùng một giải pháp cho cả hai thiết bị.

Có cách nào dễ dàng để chuyển đổi pixel sang dp không?
Bất kỳ đề xuất?

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

Tốt nhất là đặt trong một lớp 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 bằng

• .75trên ldpi( 120dpi)
• 1.0trên mdpi( 160dpi; đường cơ sở)
• 1.5trên hdpi( 240dpi)
• 2.0trên xhdpi( 320dpi)
• 3.0trên xxhdpi( 480dpi)
• 4.0trên xxxhdpi( 640dpi)

Sử dụng trình chuyển đổi trực tuyến này để chơi xung quanh với các giá trị dpi.

EDIT: Dường như không có mối quan hệ 1: 1 giữa dpixô và density. Có vẻ như bản Nexus 5Xthể xxhdpicó densitygiá trị 2.625(thay vì 3). Xem cho chính mình trong Số liệu thiết bị .

Bạn có thể sử dụng cái này .. không có ngữ cảnh

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

Như @Stan đã đề cập .. sử dụng phương pháp này có thể gây ra sự cố nếu hệ thống thay đổi mật độ. Vì vậy, hãy nhận thức về điều đó!

Cá nhân tôi đang sử dụng Bối cảnh để làm điều đó. Đó chỉ là một cách tiếp cận khác mà tôi muốn chia sẻ với bạn

Nếu bạn có thể sử dụng các kích thước XML thì rất đơn giản!

Trong của bạn res/values/dimens.xml:

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

Sau đó, trong Java của bạn:

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

Theo Hướng dẫn phát triển Android:

px = dp * (dpi / 160)

Nhưng thường thì bạn sẽ muốn thực hiện điều này theo cách khác khi bạn nhận được một thiết kế được ghi bằng pixel. Vì thế:

dp = px / (dpi / 160)

Nếu bạn đang sử dụng thiết bị 240dpi thì tỷ lệ này là 1,5 (như đã nêu trước đây), vì vậy điều này có nghĩa là biểu tượng 60px tương đương 40dp trong ứng dụng.

Không có Context, phương thức tĩnh thanh lịch:

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

Dành cho DP to Pixel

Tạo một giá trị trong dimens.xml

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

Nhận giá trị đó pixeldưới dạng:

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

Do đó, bạn có thể sử dụng công thức sau để tính toán lượng pixel phù hợp từ thứ nguyên được chỉ định trong 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);
}

Đối với bất cứ ai sử dụng Kotlin:

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

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

Sử dụng:

64.toPx
32.toDp

Có một ứng dụng mặc định trong SDK Android: http://developer.android.com/reference/android/util/TypedValue.html

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

sử dụng phần mở rộng kotlin làm cho nó tốt hơn

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

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

CẬP NHẬT:

Do displayMetricslà một phần của Tài nguyên được chia sẻ toàn cầu , chúng tôi có thể sử dụngResources.getSystem()

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

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

Điều này sẽ cung cấp cho bạn chuyển đổi dp thành pixel:

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

Điều này sẽ cung cấp cho bạn các pixel chuyển đổi thành 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)
}

Java

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

Có lẽ cách tốt nhất nếu bạn có thứ nguyên bên trong các giá trị / giảm là lấy kích thước trực tiếp từ phương thức getDimension (), nó sẽ trả về cho bạn thứ nguyên đã được chuyển đổi thành giá trị pixel.

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

Chỉ để giải thích rõ hơn về điều này,

getDimension(int resourceId) 

sẽ trả về kích thước đã được chuyển đổi thành pixel AS A FLOAT.

getDimensionPixelSize(int resourceId)

sẽ trả lại như cũ nhưng bị cắt cụt thành int, vì vậy NHƯ MỘT INTEGER.

Xem tài liệu tham khảo 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());
}

trong đó tài nguyên là bối cảnh.getResource ().

như thế này:

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

phụ thuộc vào Bối cảnh, trả về giá trị float, phương thức tĩnh

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

Cách tiếp cận thanh lịch hơn bằng cách sử dụng chức năng mở rộng của 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()

Sử dụng:

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

Trong trường hợp bạn phát triển một ứng dụng quan trọng về hiệu năng, vui lòng xem xét lớp được tối ưu hóa sau:

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

để chuyển đổi Pixels sang dp, hãy sử dụng TypedValue .

Như tài liệu đã đề cập: Container cho một giá trị dữ liệu được gõ động.

và sử dụng phương thức applicationDimension :

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

mà Chuyển đổi một giá trị dữ liệu phức tạp chưa được đóng gói giữ một thứ nguyên thành giá trị dấu phẩy động cuối cùng của nó như sau:

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

Mong rằng sẽ giúp.

Đây là cách nó hoạt động với tôi:

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

Bạn có thể làm tương tự cho chiều rộng.

Rất nhiều giải pháp tuyệt vời ở trên. Tuy nhiên, giải pháp tốt nhất tôi tìm thấy là thiết kế của google:

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

Bạn nên sử dụng dp giống như pixel của bạn. Đó là tất cả những gì họ đang có; hiển thị pixel độc lập. Sử dụng cùng một số bạn có trên màn hình mật độ trung bình và kích thước sẽ chính xác một cách kỳ diệu trên màn hình mật độ cao.

Tuy nhiên, có vẻ như những gì bạn cần là tùy chọn fill_parent trong thiết kế bố trí của bạn. Sử dụng fill_parent khi bạn muốn chế độ xem hoặc điều khiển của mình mở rộng sang tất cả các kích thước còn lại trong vùng chứa chính.

PXvà DPkhác nhau nhưng tương tự nhau.

DPlà độ phân giải khi bạn chỉ tính đến kích thước vật lý của màn hình. Khi bạn sử dụng, DPnó sẽ mở rộng bố cục của bạn sang các màn hình có kích thước tương tự khác với pixelmật độ khác nhau .

Đôi khi bạn thực sự muốn pixels, và khi bạn xử lý các kích thước trong mã, bạn luôn luôn xử lý thực pixels, trừ khi bạn chuyển đổi chúng.

Vì vậy, trên một thiết bị Android, hdpimàn hình kích thước bình thường , 800x480 is 533x320trong DP(tôi tin). Để chuyển đổi DPthành pixels /1.5, để chuyển đổi trở lại *1.5. Điều này chỉ dành cho một kích thước màn hình và dpi, nó sẽ thay đổi tùy theo thiết kế. Các nghệ sĩ của chúng tôi cho tôi pixelsmặc dù và tôi chuyển đổi DPvới 1.5phương trình trên .

Nếu bạn muốn các giá trị Integer thì sử dụng Math.round () sẽ làm tròn số float đến số nguyên gần nhất.

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

Câu trả lời tốt nhất đến từ chính khung Android: chỉ cần sử dụng sự bình đẳng này ...

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

(chuyển đổi dp thành px)

Công việc này đối với tôi (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
}

java

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