Formula px in dp, dp in px android

Sto cercando di calcolare una quantità variabile di pixel in pixel indipendenti dalla densità e viceversa.

Questa formula (px to dp): dp = (int)(px / (displayMetrics.densityDpi / 160));non funziona su piccoli dispositivi perché è divisa per zero.

Questa è la mia formula da dp a px:

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

Qualcuno potrebbe darmi dei suggerimenti?

Nota: la soluzione ampiamente utilizzata sopra è basata su displayMetrics.density. Tuttavia, i documenti spiegano che questo valore è un valore arrotondato, utilizzato con i 'secchi' dello schermo. Per esempio. sul mio Nexus 10 restituisce 2, dove il valore reale sarebbe 298 dpi (reale) / 160 dpi (impostazione predefinita) = 1,8625.

A seconda delle tue esigenze, potresti aver bisogno della trasformazione esatta, che può essere ottenuta in questo modo:

[Modifica] Questo non è pensato per essere mescolato con l'unità dp interna di Android, poiché ovviamente si basa ancora sui secchi dello schermo. Usa questo dove vuoi un'unità che dovrebbe rendere la stessa dimensione reale su dispositivi diversi.

Converti dp in pixel:

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

Converti pixel in dp:

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

Nota che ci sono proprietà xdpi e ydpi, potresti voler distinguere, ma non riesco a immaginare una visualizzazione sana in cui questi valori differiscono notevolmente.

Ho risolto il mio problema usando le seguenti formule. Possano altre persone trarne beneficio.

dp in px:

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

px a dp:

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

px a dp:

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

Modo efficiente mai

DP a Pixel:

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

Pixel a DP:

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

Spero che questo ti possa aiutare.

Chiama getResources().getDimensionPixelSize(R.dimen.your_dimension)per convertire da dpunità in pixel

Usa questa funzione

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

px = dp * (dpi / 160)

dp = px * (160 / dpi)

Nella maggior parte dei casi, le funzioni di conversione vengono chiamate frequentemente. Possiamo ottimizzarlo aggiungendo memoization. Pertanto, non viene calcolato ogni volta che viene chiamata la funzione.

Dichiariamo una HashMap che memorizzerà i valori calcolati.

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

Una funzione che calcola i valori dei pixel:

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

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

    }

Una funzione di memoization che restituisce il valore da HashMap e mantiene il record dei valori precedenti.

La memoization può essere implementata in diversi modi in Java. Per 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 supporta la funzione Lambda :

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

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

Grazie.

prova questo http://labs.skinkers.com/content/android_dp_px_calculator/

Di seguito le funzioni hanno funzionato bene per me su tutti i dispositivi.

È tratto da 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);
}

È possibile utilizzare [DisplayMatrics][1]e determinare la densità dello schermo. Qualcosa come questo:

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

Come ricordo, è meglio usare pavimenti per offset e arrotondamenti per larghezze.

Se stai cercando un calcolatore online per convertire DP, SP, pollici, millimetri, punti o pixel l'uno e l'altro a diverse densità dello schermo, questo è lo strumento più completo che io conosca .

// per ottenere in termini di decimale / virgola mobile

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

Usa queste estensioni di 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()

Sentiti libero di usare questo metodo che ho scritto:

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

La risposta accettata sopra non è completamente precisa. Secondo le informazioni ottenute ispezionando il codice sorgente Android:

Resources.getDimension()e getDimensionPixelOffset()/ getDimensionPixelSize()differiscono solo per il fatto che i primi restituiscono floatmentre gli ultimi due restituiscono lo stesso valore arrotondato in modo intappropriato. Per tutti loro, il valore restituito è in pixel non elaborati.

Tutte le tre funzioni sono implementedy chiamando Resources.getValue()e convertendo così ottenuto TypedValuechiamando TypedValue.complexToDimension(), TypedValue.complexToDimensionPixelOffset()e TypedValue.complexToDimensionPixelSize(), rispettivamente.

Pertanto, se si desidera ottenere un valore "grezzo" insieme all'unità specificata nell'origine XML, chiamare Resources.getValue()e utilizzare i metodi della TypedValueclasse.

con l'aiuto di altre risposte ho scritto questa funzione.

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

Ecco un altro modo per farlo usando le estensioni di 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)

e quindi può essere utilizzato in questo modo da qualsiasi luogo

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

    }

variazione sulla risposta ct_robs sopra, se si utilizzano numeri interi, che non solo evita la divisione per 0 produce anche un risultato utilizzabile su piccoli dispositivi:

nei calcoli interi che coinvolgono la divisione per la massima precisione, moltiplicarli prima di dividere per ridurre gli effetti di troncamento.

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

5 * 120 = 600 / 160 = 3

invece di

5 * (120 / 160 = 0) = 0

se vuoi un risultato arrotondato, fallo

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

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