Formel px zu dp, dp zu px android

Hinweis: Die weit verbreitete Lösung oben basiert auf displayMetrics.density. Aber die docs erklären Sie, daß dieser Wert ist ein gerundeter Wert, verwendet der Bildschirm 'Eimer'. ZB. auf meinem Nexus 10 es gibt 2, wo der Reale Wert wäre 298dpi (real) /160dpi (default) = 1.8625.

Je nach Ihren Anforderungen müssen Sie möglicherweise die genaue transformation, die erreicht werden kann, wie diese:

[Edit] Das soll nicht vermischt werden mit den Android-internen dp Gerät, dies ist natürlich noch auf dem Bildschirm Eimern. Verwenden Sie diese, wo Sie wollen eine Einheit, Rendern sollten die gleichen realen Größe auf verschiedenen Geräten.

Konvertieren dp-zu-pixel:

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

Konvertieren pixel zu dp:

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

Beachten Sie, dass es xdpi und ydpi Eigenschaften, möchten Sie vielleicht, um zu unterscheiden, aber ich kann mir nicht vorstellen, eine vernünftige Anzeige, wobei diese Werte sich stark unterscheiden.

InformationsquelleAutor der Antwort Bachi

px dp:

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

InformationsquelleAutor der Antwort Ian

Effiziente Möglichkeit, je

DP-zu-Pixel:

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

Pixel, DP:

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

Hoffe, dies wird Ihnen helfen.

InformationsquelleAutor der Antwort Hiren Patel

px = dp * (dpi / 160)

dp = px * (160 / dpi)

InformationsquelleAutor der Antwort ct_rob

versuchen, diese
http://labs.skinkers.com/content/android_dp_px_calculator/

InformationsquelleAutor der Antwort KMI

//für immer in Bezug auf Dezimal/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));

}

________________________________________________________________________________

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

InformationsquelleAutor der Antwort TRINADH KOYA

Können Sie [DisplayMatrics][1] und bestimmen Sie die Bildschirmauflösung. So etwas wie dieses:

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

Ich mich erinnern kann, ist es besser, einen Bodenbelag für die Abstände und Rundungen für Breite.

InformationsquelleAutor der Antwort Houcine

Die Antwort akzeptiert wird oben, ist nicht völlig zutreffend. Nach Auskunft durch Einsichtnahme in Android-source-code:

Resources.getDimension() und getDimensionPixelOffset()/getDimensionPixelSize() unterscheiden sich nur in der ehemaligen zurück float während die letzteren beiden den gleichen Wert zurückgeben, gerundet auf int appropriatelly. Für alle von Ihnen, ist der Rückgabewert ist im raw-Pixel.

Alle drei Funktionen sind implementedy durch den Aufruf Resources.getValue() und umwandeln der so erhaltenen TypedValue durch den Aufruf TypedValue.complexToDimension(), TypedValue.complexToDimensionPixelOffset() und TypedValue.complexToDimensionPixelSize() bzw.

Daher, wenn Sie "raw" - Wert zusammen mit der Einheit angegeben, die in der XML-Quelle, nennen Resources.getValue() und mit den Methoden des TypedValue Klasse.

InformationsquelleAutor der Antwort Jaromír Adamec

variation auf ct_robs Antwort oben, wenn Sie mit ganzen zahlen,, die nicht nur verhindert Division durch 0 produziert Sie auch ein brauchbares Ergebnis auf kleinen Geräten:

in integer-Berechnungen mit division für höchste Präzision multiplizieren Sie zunächst vor der Teilung zu reduzieren, abschneiden Effekte.

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

5 * 120 = 600 /160 = 3

statt

5 * (120 /160 = 0) = 0

wenn Sie möchten, abgerundete Ergebnis hierzu

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

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

InformationsquelleAutor der Antwort user2624395