Conversione di pixel in dp

Ho creato la mia applicazione con l'altezza e la larghezza espresse in pixel per un dispositivo Pantech la cui risoluzione è 480x800.

Devo convertire l'altezza e la larghezza per un dispositivo G1.
Ho pensato che convertirlo in dp risolverà il problema e fornirà la stessa soluzione per entrambi i dispositivi.

Esiste un modo semplice per convertire i pixel in dp?
Eventuali suggerimenti?

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

Preferibilmente, inserire una 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 è uguale a

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

Usa questo convertitore online per giocare con i valori dpi.

EDIT: Sembra che non ci sia una relazione 1: 1 tra dpibucket e density. Sembra che l' Nexus 5Xessere xxhdpiabbia un densityvalore di 2.625(anziché 3). Guarda tu stesso nelle metriche del dispositivo .

Puoi usarlo .. senza contesto

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

Come accennato da @Stan .. l'utilizzo di questo approccio può causare problemi se il sistema cambia densità. Quindi state attenti!

Personalmente sto usando il contesto per farlo. È solo un altro approccio con cui volevo condividerti

Se puoi usare le dimensioni XML è molto semplice!

Nel tuo res/values/dimens.xml:

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

Quindi nel tuo Java:

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

Secondo la Guida allo sviluppo di Android:

px = dp * (dpi / 160)

Ma spesso ti consigliamo di farlo al contrario quando ricevi un disegno che è dichiarato in pixel. Così:

dp = px / (dpi / 160)

Se utilizzi un dispositivo da 240 dpi, questo rapporto è 1,5 (come indicato in precedenza), quindi significa che un'icona da 60px equivale a 40dp nell'applicazione.

Senza Context, eleganti metodi statici:

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

Per DP to Pixel

Crea un valore in dimens.xml

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

Ottieni quel valore pixelcome:

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

È quindi possibile utilizzare il seguente formulatore per calcolare la giusta quantità di pixel da una dimensione specificata in 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);
}

Per chiunque usi Kotlin:

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

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

Uso:

64.toPx
32.toDp

Esiste un programma di utilità predefinito in Android SDK: http://developer.android.com/reference/android/util/TypedValue.html

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

l'utilizzo di kotlin-extension lo rende migliore

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

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

AGGIORNARE:

Perché displayMetricsfa parte delle risorse condivise globali , possiamo usareResources.getSystem()

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

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

Questo dovrebbe darti la conversione dp in pixel:

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

Questo dovrebbe darti i pixel di conversione in 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)
}

Giava

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

Probabilmente il modo migliore se hai la dimensione all'interno di valori / dimen è ottenere la dimensione direttamente dal metodo getDimension (), ti restituirà la dimensione già convertita in valore di pixel.

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

Giusto per spiegare meglio questo,

getDimension(int resourceId) 

restituirà la dimensione già convertita in pixel COME A FLOAT.

getDimensionPixelSize(int resourceId)

restituirà lo stesso ma troncato a int, quindi COME UN INTEGER.

Vedi riferimento 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());
}

dove la risorsa è context.getResources ().

come questo:

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

dipende dal contesto, restituisce valore float, metodo statico

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

Approccio più elegante usando la funzione di estensione di 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()

Uso:

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

Nel caso in cui si sviluppi un'applicazione critica per le prestazioni, considerare la seguente classe ottimizzata:

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

per convertire i pixel in dp usa TypedValue .

Come menzionato nella documentazione: Contenitore per un valore di dati tipizzato dinamicamente.

e usa il metodo applyDimension :

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

che converte un valore di dati complessi non compressi che contiene una dimensione al suo valore in virgola mobile finale come il seguente:

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

Spero che aiuti .

Funziona così per me:

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

Puoi fare lo stesso per la larghezza.

Molte grandi soluzioni sopra. Tuttavia, la migliore soluzione che ho trovato è il design di google:

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

Dovresti usare dp come faresti con i pixel. Questo è tutto ciò che sono; visualizzare pixel indipendenti. Usa gli stessi numeri che avresti su uno schermo a media densità e le dimensioni saranno magicamente corrette su uno schermo ad alta densità.

Tuttavia, sembra che ciò di cui hai bisogno sia l'opzione fill_parent nella progettazione del layout. Utilizzare fill_parent quando si desidera che la vista o il controllo si espanda a tutte le dimensioni rimanenti nel contenitore padre.

PXe DPsono diversi ma simili.

DPè la risoluzione quando si calcola solo la dimensione fisica dello schermo. Quando lo usi DPridimensiona il layout su schermi di dimensioni simili con dimensioni diversepixel densità .

Occasionalmente pixels, tuttavia, in realtà lo desideri , e quando hai a che fare con dimensioni in codice hai sempre a che fare con reale pixels, a meno che non le converti.

Quindi su un dispositivo Android, hdpischermo di dimensioni normali , 800x480 is 533x320in DP(credo). Per convertire DPin pixels /1.5, per riconvertire *1.5. Questo è solo per la dimensione di uno schermo e dpi, cambierebbe a seconda del design. I nostri artisti mi danno pixelsperò e mi converto DPcon l' 1.5equazione sopra .

Se vuoi valori interi , allora usando Math.round () arrotonderai il float all'intero più vicino.

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

La migliore risposta arriva dal framework Android stesso: basta usare questa uguaglianza ...

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

(converte dp in px)

Questo lavoro per me (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
}

Giava

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