สูตร px เป็น dp, dp ถึง px android

ฉันกำลังพยายามคำนวณจำนวนพิกเซลของพิกเซลเพื่อความหนาแน่นของพิกเซลอิสระและในทางกลับกัน

สูตรนี้ใช้(px to dp): dp = (int)(px / (displayMetrics.densityDpi / 160));ไม่ได้กับอุปกรณ์ขนาดเล็กเนื่องจากถูกหารด้วยศูนย์

นี่คือสูตร dp ถึง px ของฉัน:

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

ใครช่วยชี้ให้ฉันได้บ้าง

หมายเหตุ: displayMetrics.densityการแก้ปัญหาการใช้กันอย่างแพร่หลายดังกล่าวข้างต้นจะขึ้นอยู่กับ อย่างไรก็ตามเอกสารอธิบายว่าค่านี้เป็นค่าปัดเศษที่ใช้กับหน้าจอ 'ที่เก็บข้อมูล' เช่น. บน Nexus 10 ของฉันมันจะคืนค่า 2 โดยที่มูลค่าจริงจะเป็น 298dpi (จริง) / 160dpi (ค่าเริ่มต้น) = 1.8625

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

[แก้ไข] สิ่งนี้ไม่ได้มีไว้เพื่อผสมกับหน่วย dp ภายในของ Android เนื่องจากแน่นอนว่ายังคงใช้ถังหน้าจอ ใช้สิ่งนี้ในที่ที่คุณต้องการหน่วยที่ควรแสดงผลขนาดจริงบนอุปกรณ์ที่แตกต่างกัน

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

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

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

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

โปรดทราบว่ามีคุณสมบัติ xdpi และ ydpi คุณอาจต้องการแยกความแตกต่าง แต่ฉันไม่สามารถจินตนาการการแสดงผลที่มีค่าที่แตกต่างกันอย่างมาก

ฉันแก้ไขปัญหาโดยใช้สูตรต่อไปนี้ คนอื่นอาจได้รับประโยชน์จากมัน

dp ถึง px:

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

px ถึง dp:

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

px ถึง dp:

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

ได้อย่างมีประสิทธิภาพเลยทีเดียว

DP เป็นพิกเซล:

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

พิกเซลเป็น DP:

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

หวังว่านี่จะช่วยคุณได้

เพียงแค่เรียกgetResources().getDimensionPixelSize(R.dimen.your_dimension)ให้แปลงจากdpหน่วยเป็นพิกเซล

ใช้ฟังก์ชั่นนี้

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

px = dp * (dpi / 160)

dp = px * (160 / dpi)

ในกรณีส่วนใหญ่ฟังก์ชั่นการแปลงจะถูกเรียกบ่อยครั้ง เราสามารถปรับให้เหมาะสมด้วยการเพิ่มการบันทึก ดังนั้นจึงไม่คำนวณทุกครั้งที่มีการเรียกใช้ฟังก์ชัน

มาประกาศ HashMap ที่จะเก็บค่าที่คำนวณได้

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

ฟังก์ชั่นที่คำนวณค่าพิกเซล:

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

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

    }

ฟังก์ชั่นบันทึกความจำที่ส่งคืนค่าจาก HashMap และเก็บรักษาบันทึกของค่าก่อนหน้า

การบันทึกสามารถนำไปใช้ได้หลายวิธีใน Java สำหรับ 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 รองรับฟังก์ชั่น Lambda :

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

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

ขอบคุณ

ลองhttp://labs.skinkers.com/content/android_dp_px_calculator/นี้

funtions ด้านล่างทำงานได้ดีสำหรับฉันในทุกอุปกรณ์

นำมาจาก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);
}

คุณสามารถใช้[DisplayMatrics][1]และกำหนดความหนาแน่นของหน้าจอ บางสิ่งเช่นนี้

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

เพราะฉันจำได้ว่าควรใช้พื้นสำหรับออฟเซ็ตและปัดเศษเพื่อความกว้าง

หากคุณกำลังมองหาเครื่องคิดเลขออนไลน์สำหรับการแปลง DP, SP, นิ้วมิลลิเมตรจุดหรือพิกเซลไปและกลับจากอีกคนหนึ่งที่มีความหนาแน่นของหน้าจอที่แตกต่างกันนี้เป็นเครื่องมือที่สมบูรณ์แบบที่สุดที่ฉันรู้

// เพื่อรับในรูปของทศนิยม / ลอย

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

ใช้ส่วนขยาย Kotlin เหล่านี้:

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

รู้สึกอิสระที่จะใช้วิธีนี้ฉันเขียนว่า:

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

คำตอบที่ได้รับการยอมรับข้างต้นไม่ถูกต้องสมบูรณ์ ตามข้อมูลที่ได้จากการตรวจสอบซอร์สโค้ด Android:

Resources.getDimension()และgetDimensionPixelOffset()/ getDimensionPixelSize()แตกต่างกันเฉพาะในอดีตที่กลับมาfloatในขณะที่ทั้งสองหลังกลับค่าเดียวกันปัดเศษเพื่อความintเหมาะสม สำหรับพวกเขาทั้งหมดค่าตอบแทนอยู่ในพิกเซลดิบ

ทั้งสามฟังก์ชั่น implementedy โดยการโทรResources.getValue()และการแปลงจึงได้TypedValueโดยการโทรTypedValue.complexToDimension(), TypedValue.complexToDimensionPixelOffset()และTypedValue.complexToDimensionPixelSize()ตามลำดับ

ดังนั้นหากคุณต้องการรับค่า "raw" พร้อมกับหน่วยที่ระบุในแหล่ง XML ให้เรียกResources.getValue()และใช้เมธอดของTypedValueคลาส

ด้วยความช่วยเหลือของคำตอบอื่น ๆ ฉันเขียนฟังก์ชั่นนี้

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

นี่เป็นวิธีอื่นในการใช้ส่วนขยาย 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)

และจากนั้นมันสามารถใช้งานได้จากทุกที่

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

    }

รูปแบบของคำตอบ ct_robs ด้านบนหากคุณใช้จำนวนเต็มซึ่งไม่เพียง แต่หลีกเลี่ยงการหารด้วย 0 มันยังสร้างผลลัพธ์ที่ใช้งานได้บนอุปกรณ์ขนาดเล็ก:

ในการคำนวณจำนวนเต็มที่เกี่ยวข้องกับการหารเพื่อความแม่นยำที่ยิ่งใหญ่ที่สุดคูณก่อนที่จะหารเพื่อลดผลกระทบที่ถูกตัดทอน

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

5 * 120 = 600 / 160 = 3

แทน

5 * (120 / 160 = 0) = 0

ถ้าคุณต้องการผลปัดเศษทำเช่นนี้

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

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