การแปลงพิกเซลเป็น dp

ผมได้สร้างแอพลิเคชันของฉันกับความสูงและความกว้างที่กำหนดในพิกเซลสำหรับอุปกรณ์ Pantech 480x800ที่มีความละเอียด

ฉันต้องการแปลงความสูงและความกว้างสำหรับอุปกรณ์ G1
ฉันคิดว่าการแปลงเป็น dp จะแก้ปัญหาและให้วิธีแก้ปัญหาเดียวกันสำหรับอุปกรณ์ทั้งสอง

มีวิธีง่าย ๆ ในการแปลงพิกเซลเป็น DP?
ข้อเสนอแนะใด ๆ

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

ใส่ไว้ในคลาส 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 เท่ากับ

• .75บนldpi( 120dpi)
• 1.0บนmdpi( 160dpi; พื้นฐาน)
• 1.5บนhdpi( 240dpi)
• 2.0บนxhdpi( 320dpi)
• 3.0บนxxhdpi( 480dpi)
• 4.0บนxxxhdpi( 640dpi)

ใช้ตัวแปลงออนไลน์นี้เพื่อเล่นด้วยค่า dpi

แก้ไข: ดูเหมือนว่าไม่มี 1: 1 ความสัมพันธ์ระหว่างถังและdpi densityดูเหมือนว่าสิ่งมีNexus 5Xชีวิตxxhdpiมีdensityค่าเป็น2.625(แทน3) ดูตัวเองในการวัดอุปกรณ์

คุณสามารถใช้สิ่งนี้ .. โดยไม่มีบริบท

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

ตามที่ @Stan กล่าวถึง .. การใช้วิธีการนี้อาจทำให้เกิดปัญหาหากระบบเปลี่ยนความหนาแน่น ดังนั้นจงระวังให้ดี!

โดยส่วนตัวฉันใช้บริบทเพื่อทำเช่นนั้น เป็นอีกแนวทางหนึ่งที่ฉันต้องการแบ่งปันให้คุณ

หากคุณสามารถใช้ขนาด XML มันง่ายมาก!

ในres/values/dimens.xml:

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

จากนั้นใน Java ของคุณ:

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

ตามคู่มือการพัฒนา Android:

px = dp * (dpi / 160)

แต่บ่อยครั้งที่คุณต้องการดำเนินการนี้ในทางกลับกันเมื่อคุณได้รับการออกแบบที่ระบุเป็นพิกเซล ดังนั้น:

dp = px / (dpi / 160)

หากคุณใช้อุปกรณ์ 240dpi อัตราส่วนนี้คือ 1.5 (เช่นที่ระบุไว้ก่อนหน้านี้) ดังนั้นหมายความว่าไอคอน 60px เท่ากับ 40dp ในแอปพลิเคชัน

ไม่มีContextวิธีคงที่สง่างาม:

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

สำหรับ DP to Pixel

สร้างมูลค่าใน dimens.xml

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

รับค่านั้นpixelเป็น:

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

คุณสามารถใช้ formulator ต่อไปนี้เพื่อคำนวณจำนวนพิกเซลที่ถูกต้องจากส่วนข้อมูลที่ระบุใน 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);
}

สำหรับทุกคนที่ใช้ Kotlin:

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

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

การใช้งาน:

64.toPx
32.toDp

มีการใช้งานเริ่มต้นใน android SDK: http://developer.android.com/reference/android/util/TypedValue.html

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

การใช้ kotlin-extension ทำให้ดีขึ้น

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

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

UPDATE:

เนื่องจากdisplayMetricsเป็นส่วนหนึ่งของทรัพยากรที่ใช้ร่วมกันทั่วโลกเราจึงสามารถใช้Resources.getSystem()

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

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

สิ่งนี้จะให้การแปลง DP เป็นพิกเซล:

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

สิ่งนี้จะให้พิกเซลการแปลงแก่คุณเป็น 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)
}

ชวา

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

อาจเป็นวิธีที่ดีที่สุดถ้าคุณมีมิติภายในค่า / dimen คือรับมิติโดยตรงจากเมธอด getDimension () มันจะคืนค่าขนาดที่แปลงเป็นค่าพิกเซลแล้ว

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

เพื่ออธิบายสิ่งนี้ให้ดีขึ้น

getDimension(int resourceId) 

จะส่งคืนมิติที่แปลงเป็นพิกเซล AS A FLOAT

getDimensionPixelSize(int resourceId)

จะกลับมาเหมือนเดิม แต่ถูกปัดเศษเป็น int ดังนั้นในฐานะที่เป็น INTEGER

ดูการอ้างอิง 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());
}

โดยที่ resource คือ context.getResources ()

แบบนี้:

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

ขึ้นอยู่กับบริบทคืนค่าลอยวิธีการคงที่

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

วิธีการที่หรูหรากว่าโดยใช้ฟังก์ชั่นเสริมของ 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()

การใช้งาน:

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

ในกรณีที่คุณพัฒนาแอพพลิเคชั่นที่สำคัญเกี่ยวกับประสิทธิภาพโปรดพิจารณาคลาสที่ปรับให้เหมาะสมดังต่อไปนี้:

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

การแปลงพิกเซลเพื่อ DP ใช้TypedValue

ตามเอกสารที่กล่าวมา: คอนเทนเนอร์สำหรับค่าข้อมูลที่พิมพ์แบบไดนามิก

และใช้วิธีApplyDimension :

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

ซึ่งแปลงค่าของข้อมูลที่ซับซ้อนที่ยังไม่ได้บรรจุซึ่งบรรจุมิติเป็นค่าจุดลอยตัวสุดท้ายดังต่อไปนี้:

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

หวังว่าจะช่วย

นี่คือวิธีการทำงานสำหรับฉัน:

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

คุณสามารถทำเช่นเดียวกันสำหรับความกว้าง

โซลูชั่นที่ยอดเยี่ยมมากมาย อย่างไรก็ตามทางออกที่ดีที่สุดที่ฉันพบคือการออกแบบของ Google:

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

คุณควรใช้ dp เช่นเดียวกับที่คุณทำกับพิกเซล นั่นคือทั้งหมดที่พวกเขา; แสดงพิกเซลอิสระ ใช้ตัวเลขเดียวกันกับที่คุณทำบนหน้าจอความหนาแน่นปานกลางและขนาดจะถูกต้องอย่างน่าอัศจรรย์บนหน้าจอความหนาแน่นสูง

อย่างไรก็ตามดูเหมือนสิ่งที่คุณต้องการคือตัวเลือก fill_parent ในการออกแบบเลย์เอาต์ของคุณ ใช้ fill_parent เมื่อคุณต้องการให้มุมมองหรือตัวควบคุมของคุณขยายขนาดที่เหลือทั้งหมดในคอนเทนเนอร์พาเรนต์

PXและDPแตกต่างกัน แต่คล้ายกัน

DPคือความละเอียดเมื่อคุณคำนึงถึงขนาดทางกายภาพของหน้าจอเท่านั้น เมื่อคุณใช้DPมันจะปรับขนาดเลย์เอาต์ของคุณไปยังหน้าจออื่นที่มีขนาดใกล้เคียงกันซึ่งมีpixelความหนาแน่นต่างกัน

บางครั้งคุณต้องการจริง ๆpixelsและเมื่อคุณจัดการกับส่วนข้อมูลในรหัสคุณมักจะจัดการกับของจริงpixelsเว้นแต่คุณจะแปลง

ดังนั้นบนอุปกรณ์ Android hdpiหน้าจอขนาดปกติ800x480 is 533x320ในDP(ฉันเชื่อว่า) การแปลงDPเข้าpixels /1.5, *1.5การแปลงกลับ นี่เป็นเพียงขนาดหน้าจอเดียวและdpiมันจะเปลี่ยนไปตามการออกแบบ ศิลปินของเราให้ฉันpixelsและฉันก็เปลี่ยนDPเป็น1.5สมการข้างบน

ถ้าคุณต้องการค่าจำนวนเต็มการใช้ Math.round () จะปัดเศษทศนิยมเป็นจำนวนเต็มที่ใกล้เคียงที่สุด

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

workds สำหรับฉัน (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
}

ชวา

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

คำตอบที่ดีที่สุดมาจากกรอบของ Android: เพียงแค่ใช้ความเท่าเทียมกันนี้ ...

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

(แปลง dp เป็น px)