Formel px zu dp, dp zu px android

Ich versuche, eine variable Anzahl von Pixeln zu dichteunabhängigen Pixeln zu berechnen und umgekehrt.

Diese Formel (px to dp): dp = (int)(px / (displayMetrics.densityDpi / 160));funktioniert bei kleinen Geräten nicht, da sie durch Null geteilt wird.

Dies ist meine dp to px Formel:

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

Könnte mir jemand ein paar Hinweise geben?

Hinweis: Die oben weit verbreitete Lösung basiert auf displayMetrics.density. In den Dokumenten wird jedoch erläutert, dass es sich bei diesem Wert um einen gerundeten Wert handelt, der mit den Bildschirm-Buckets verwendet wird. Z.B. Auf meinem Nexus 10 wird 2 zurückgegeben, wobei der tatsächliche Wert 298 dpi (real) / 160 dpi (Standard) = 1,8625 beträgt.

Abhängig von Ihren Anforderungen benötigen Sie möglicherweise die genaue Transformation, die folgendermaßen erreicht werden kann:

[Bearbeiten] Dies ist nicht dazu gedacht, mit der internen dp-Einheit von Android gemischt zu werden, da dies natürlich immer noch auf den Bildschirm-Buckets basiert. Verwenden Sie diese Option, wenn Sie eine Einheit wünschen, die auf verschiedenen Geräten dieselbe tatsächliche Größe wiedergeben soll.

Konvertiere dp in Pixel:

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

Pixel in dp konvertieren:

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 gibt, die Sie vielleicht unterscheiden möchten, aber ich kann mir keine vernünftige Anzeige vorstellen, bei der sich diese Werte stark unterscheiden.

Ich habe mein Problem mit den folgenden Formeln gelöst. Mögen andere Menschen davon profitieren.

dp bis px:

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

px bis dp:

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

px bis dp:

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

Effizienter Weg überhaupt

DP zu Pixel:

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

Pixel zu DP:

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

Hoffe das wird dir helfen.

Rufen Sie einfach getResources().getDimensionPixelSize(R.dimen.your_dimension)an, um von dpEinheiten in Pixel zu konvertieren

Verwenden Sie diese Funktion

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

px = dp * (dpi / 160)

dp = px * (160 / dpi)

In den meisten Fällen werden Konvertierungsfunktionen häufig aufgerufen. Wir können es optimieren, indem wir Memoisierung hinzufügen. Es wird also nicht jedes Mal berechnet, wenn die Funktion aufgerufen wird.

Deklarieren wir eine HashMap, in der die berechneten Werte gespeichert werden.

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

Eine Funktion, die Pixelwerte berechnet:

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

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

    }

Eine Memo-Funktion, die den Wert von HashMap zurückgibt und die Aufzeichnung vorheriger Werte verwaltet.

Memoization kann in Java auf verschiedene Arten implementiert werden. Für 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 unterstützt die Lambda-Funktion :

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

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

Vielen Dank.

Versuchen Sie dies http://labs.skinkers.com/content/android_dp_px_calculator/

Die folgenden Funktionen haben für mich geräteübergreifend gut funktioniert.

Es stammt von 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);
}

Sie können [DisplayMatrics][1]die Bildschirmdichte verwenden und bestimmen. Etwas wie das:

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

Wie ich mich erinnere, ist es besser, Bodenbeläge für Versätze und Rundungen für Breiten zu verwenden.

Wenn Sie nach einem Online-Rechner suchen, mit dem Sie DP, SP, Zoll, Millimeter, Punkte oder Pixel mit unterschiedlichen Bildschirmdichten voneinander und voneinander konvertieren können, ist dies das umfassendste Tool, das ich kenne .

// um in Dezimal / Float zu kommen

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

Verwenden Sie diese Kotlin-Erweiterungen:

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

Fühlen Sie sich frei, diese Methode zu verwenden, die ich geschrieben habe:

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

Die oben akzeptierte Antwort ist nicht vollständig korrekt. Nach Informationen, die durch Überprüfen des Android-Quellcodes erhalten wurden:

Resources.getDimension()und getDimensionPixelOffset()/ getDimensionPixelSize()unterscheiden sich nur darin, dass die ersteren zurückgeben, floatwährend die beiden letzteren den gleichen Wert zurückgeben, der auf intangemessen gerundet ist . Für alle ist der Rückgabewert in Rohpixeln angegeben.

Alle drei Funktionen werden durch Aufruf implementiert Resources.getValue() und die Umwandlung so erhaltenen TypedValuedurch den Aufruf TypedValue.complexToDimension(), TypedValue.complexToDimensionPixelOffset()und TypedValue.complexToDimensionPixelSize(), respectively.

Wenn Sie daher einen "Rohwert" zusammen mit der in der XML-Quelle angegebenen Einheit erhalten möchten, rufen Sie Resources.getValue()die Methoden der TypedValueKlasse auf und verwenden Sie sie .

Mit Hilfe anderer Antworten habe ich diese Funktion geschrieben.

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

Hier ist eine andere Möglichkeit, dies mit Kotlin-Erweiterungen zu tun:

val Int.dpToPx: Int
    get() = Math.round(this * Resources.getSystem().displayMetrics.density)

val Int.pxToDp: Int
    get() = Math.round(this / Resources.getSystem().displayMetrics.density)

und dann kann es von überall so verwendet werden

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

    }

Variation der obigen Antwort von ct_robs: Wenn Sie Ganzzahlen verwenden, wird nicht nur die Division durch 0 vermieden, sondern auch auf kleinen Geräten ein brauchbares Ergebnis erzielt:

Bei Ganzzahlberechnungen mit Division für höchste Präzision multiplizieren Sie zuerst, bevor Sie dividieren, um Kürzungseffekte zu reduzieren.

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

5 * 120 = 600 / 160 = 3

anstatt

5 * (120 / 160 = 0) = 0

Wenn Sie ein abgerundetes Ergebnis wünschen, tun Sie dies

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

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