Formule px à dp, dp à px android

J'essaie de calculer une quantité variable de pixels en pixels indépendants de la densité et vice-versa.

Cette formule (px to dp): dp = (int)(px / (displayMetrics.densityDpi / 160));ne fonctionne pas sur les petits appareils car elle est divisée par zéro.

Voici ma formule dp en px:

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

Quelqu'un pourrait-il me donner des conseils?

Remarque: la solution largement utilisée ci-dessus est basée sur displayMetrics.density. Cependant, la documentation explique que cette valeur est une valeur arrondie, utilisée avec l'écran «buckets». Par exemple. sur mon Nexus 10, il renvoie 2, où la valeur réelle serait 298 dpi (réel) / 160 dpi (par défaut) = 1,8625.

En fonction de vos besoins, vous pourriez avoir besoin de la transformation exacte, qui peut être réalisée comme ceci:

[Modifier] Ceci n'est pas destiné à être mélangé avec l'unité dp interne d'Android, car cela est bien sûr toujours basé sur les seaux d'écran. Utilisez-le là où vous voulez une unité qui devrait rendre la même taille réelle sur différents appareils.

Convertir dp en pixel:

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

Convertir le pixel en dp:

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

Notez qu'il existe des propriétés xdpi et ydpi, que vous voudrez peut-être distinguer, mais je ne peux pas imaginer un affichage sain où ces valeurs diffèrent considérablement.

J'ai résolu mon problème en utilisant les formules suivantes. Que d'autres personnes en bénéficient.

dp en 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());

Une manière efficace jamais

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

J'espère que ceci vous aidera.

Appelez simplement getResources().getDimensionPixelSize(R.dimen.your_dimension)pour convertir des dpunités en pixels

Utilisez cette fonction

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

px = dp * (dpi / 160)

dp = px * (160 / dpi)

Dans la plupart des cas, les fonctions de conversion sont fréquemment appelées. Nous pouvons l'optimiser en ajoutant la mémorisation. Ainsi, il ne calcule pas chaque fois que la fonction est appelée.

Déclarons un HashMap qui stockera les valeurs calculées.

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

Une fonction qui calcule les valeurs des pixels:

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

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

    }

Une fonction de mémorisation qui renvoie la valeur de HashMap et conserve l'enregistrement des valeurs précédentes.

La mémorisation peut être implémentée de différentes manières en Java. Pour 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 prend en charge la fonction Lambda :

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

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

Merci.

essayez ceci http://labs.skinkers.com/content/android_dp_px_calculator/

Les fonctions ci-dessous ont bien fonctionné pour moi sur tous les appareils.

Il est tiré de 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);
}

Vous pouvez utiliser [DisplayMatrics][1]et déterminer la densité de l'écran. Quelque chose comme ça:

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

Si je me souviens bien, il est préférable d'utiliser un revêtement de sol pour les décalages et l'arrondi pour les largeurs.

Si vous recherchez une calculatrice en ligne pour convertir DP, SP, pouces, millimètres, points ou pixels entre eux à différentes densités d'écran, c'est l'outil le plus complet que je connaisse .

// pour obtenir en termes de décimal / flottant

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

Utilisez ces extensions 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()

N'hésitez pas à utiliser cette méthode que j'ai écrite:

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

La réponse acceptée ci-dessus n'est pas entièrement exacte. Selon les informations obtenues en inspectant le code source Android:

Resources.getDimension()et getDimensionPixelOffset()/ getDimensionPixelSize()ne diffèrent que par le fait que le premier retourne floatalors que les deux derniers renvoient la même valeur arrondie de intmanière appropriée. Pour tous, la valeur de retour est en pixels bruts.

Les trois fonctions sont implémentées en appelant Resources.getValue()et en convertissant ainsi obtenues TypedValueen appelant TypedValue.complexToDimension(), TypedValue.complexToDimensionPixelOffset()et TypedValue.complexToDimensionPixelSize(), respectivement.

Par conséquent, si vous souhaitez obtenir une valeur "brute" avec l'unité spécifiée dans la source XML, appelez Resources.getValue()et utilisez les méthodes de la TypedValueclasse.

avec l'aide d'autres réponses, j'ai écrit cette fonction.

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

Voici une autre façon de le faire en utilisant les extensions 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)

et puis il peut être utilisé comme ça de n'importe où

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 sur la réponse ct_robs ci-dessus, si vous utilisez des entiers, cela évite non seulement de diviser par 0, mais produit également un résultat utilisable sur de petits appareils:

dans les calculs d'entiers impliquant une division pour une plus grande précision, multipliez d'abord avant de diviser pour réduire les effets de troncature.

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

5 * 120 = 600 / 160 = 3

au lieu de

5 * (120 / 160 = 0) = 0

si vous voulez un résultat arrondi, faites ceci

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

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