Conversion de pixels en dp

J'ai créé mon application avec la hauteur et la largeur données en pixels pour un appareil Pantech dont la résolution est 480x800.

Je dois convertir la hauteur et la largeur d'un appareil G1.
Je pensais que le convertir en dp résoudrait le problème et fournirait la même solution pour les deux appareils.

Existe-t-il un moyen simple de convertir des pixels en dp?
Aucune suggestion?

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

Mettez de préférence dans une classe 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 équivaut à

• .75le ldpi( 120dpi)
• 1.0sur mdpi( 160dpi; base)
• 1.5le hdpi( 240dpi)
• 2.0le xhdpi( 320dpi)
• 3.0le xxhdpi( 480dpi)
• 4.0le xxxhdpi( 640dpi)

Utilisez ce convertisseur en ligne pour jouer avec les valeurs dpi.

EDIT: Il semble qu'il n'y ait pas de relation 1: 1 entre le dpiseau et density. Il semble que l' Nexus 5Xêtre xxhdpiait une densityvaleur de 2.625(au lieu de 3). Voyez par vous-même dans les métriques de l' appareil .

Vous pouvez l'utiliser .. sans contexte

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

Comme @Stan l'a mentionné .. l'utilisation de cette approche peut entraîner des problèmes si le système change de densité. Alors soyez conscient de ça!

Personnellement, j'utilise Context pour cela. C'est juste une autre approche avec laquelle je voulais vous partager

Si vous pouvez utiliser les dimensions XML, c'est très simple!

Dans votre res/values/dimens.xml:

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

Puis dans votre Java:

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

Selon le Guide de développement Android:

px = dp * (dpi / 160)

Mais souvent, vous voudrez effectuer cette opération dans l'autre sens lorsque vous recevrez un design exprimé en pixels. Donc:

dp = px / (dpi / 160)

Si vous utilisez un appareil à 240 dpi, ce rapport est de 1,5 (comme indiqué précédemment), cela signifie donc qu'une icône de 60 pixels équivaut à 40 dpi dans l'application.

Sans Contextméthodes statiques élégantes:

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

Pour DP to Pixel

Créer une valeur dans dimens.xml

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

Obtenez cette valeur en pixeltant que:

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

Vous pouvez donc utiliser le formulateur suivant pour calculer la bonne quantité de pixels à partir d'une dimension spécifiée en 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);
}

Pour toute personne utilisant Kotlin:

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

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

Usage:

64.toPx
32.toDp

Il existe un utilitaire par défaut dans le SDK Android: http://developer.android.com/reference/android/util/TypedValue.html

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

utiliser kotlin-extension le rend meilleur

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

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

MISE À JOUR:

En raison de displayMetricsfait partie des ressources partagées mondiales , nous pouvons utiliserResources.getSystem()

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

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

Cela devrait vous donner la conversion dp en pixels:

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

Cela devrait vous donner les pixels de conversion en 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)
}

Java

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

Probablement la meilleure façon si vous avez la dimension à l'intérieur des valeurs / dimen est d'obtenir la dimension directement à partir de la méthode getDimension (), elle vous renverra la dimension déjà convertie en valeur de pixel.

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

Juste pour mieux expliquer cela,

getDimension(int resourceId) 

renverra la dimension déjà convertie en pixel COMME UN FLOTTEUR.

getDimensionPixelSize(int resourceId)

retournera le même mais tronqué à int, donc COMME UN ENTIER.

Voir la référence 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());
}

où ressource est context.getResources ().

comme ça:

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

dépend du contexte, retourne la valeur flottante, méthode statique

à partir de: https://github.com/Trinea/android-common/blob/master/src/cn/trinea/android/common/util/ScreenUtils.java#L15

Approche plus élégante utilisant la fonction d'extension de 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()

Usage:

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

Si vous développez une application critique pour les performances, veuillez considérer la classe optimisée suivante:

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

pour convertir des pixels en dp, utilisez TypedValue .

Comme mentionné dans la documentation: Conteneur pour une valeur de données typée dynamiquement.

et utilisez la méthode applyDimension :

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

qui convertit une valeur de données complexes non compressée contenant une dimension en sa valeur finale en virgule flottante comme suit:

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

J'espère que cela pourra aider .

Voici comment cela fonctionne pour moi:

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

Vous pouvez faire de même pour la largeur.

Beaucoup de bonnes solutions ci-dessus. Cependant, la meilleure solution que j'ai trouvée est la conception de Google:

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

Vous devez utiliser dp comme vous le feriez avec des pixels. C'est tout ce qu'ils sont; afficher des pixels indépendants. Utilisez les mêmes nombres que vous le feriez sur un écran de densité moyenne, et la taille sera magiquement correcte sur un écran de haute densité.

Cependant, il semble que vous ayez besoin de l'option fill_parent dans votre conception de mise en page. Utilisez fill_parent lorsque vous souhaitez que votre vue ou contrôle s'étende à toute la taille restante dans le conteneur parent.

PXet DPsont différents mais similaires.

DPest la résolution lorsque vous ne tenez compte que de la taille physique de l'écran. Lorsque vous l'utilisez DP, votre disposition sera mise à l'échelle sur d'autres écrans de taille similaire avec des pixeldensités différentes .

Parfois, vous le souhaitez pixels, et lorsque vous traitez avec des dimensions dans du code, vous traitez toujours avec de la réalité pixels, sauf si vous les convertissez.

Donc, sur un appareil Android, un hdpiécran de taille normale , 800x480 is 533x320en DP(je crois). Pour convertir DPen pixels /1.5, pour reconvertir *1.5. Ce n'est que pour la taille d'écran unique dpi, et cela changerait selon la conception. Nos artistes me donnent pixelscependant et je me convertis à DPl' 1.5équation ci-dessus .

Si vous voulez des valeurs entières , l'utilisation de Math.round () arrondira le flottant à l'entier le plus proche.

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

La meilleure réponse vient du framework Android lui-même: utilisez simplement cette égalité ...

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

(convertit dp en px)

Cela fonctionne pour moi (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
}

Java

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