Convertir píxeles a dp

He creado mi aplicación con la altura y el ancho dados en píxeles para un dispositivo Pantech cuya resolución es 480x800.

Necesito convertir la altura y el ancho de un dispositivo G1.
Pensé que convertirlo en dp resolvería el problema y proporcionaría la misma solución para ambos dispositivos.

¿Hay alguna manera fácil de convertir píxeles a dp?
¿Alguna sugerencia?

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

Preferiblemente poner en una clase 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 es igual

• .75encendido ldpi( 120ppp)
• 1.0encendido mdpi( 160ppp; línea de base)
• 1.5encendido hdpi( 240ppp)
• 2.0encendido xhdpi( 320ppp)
• 3.0encendido xxhdpi( 480ppp)
• 4.0encendido xxxhdpi( 640ppp)

Use este convertidor en línea para jugar con los valores de dpi.

EDITAR: Parece que no hay una relación 1: 1 entre el dpicubo y density. Parece que el Nexus 5Xser xxhdpitiene un densityvalor de 2.625(en lugar de 3). Véalo usted mismo en las métricas del dispositivo .

Puedes usar esto ... sin contexto

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

Como mencionó @Stan ... el uso de este enfoque puede causar problemas si el sistema cambia la densidad. ¡Entonces sé consciente de eso!

Personalmente estoy usando Context para hacer eso. Es solo otro enfoque con el que quería compartirlo

Si puede usar las dimensiones XML, ¡es muy simple!

En su res/values/dimens.xml:

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

Luego en tu Java:

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

De acuerdo con la Guía de desarrollo de Android:

px = dp * (dpi / 160)

Pero a menudo querrá realizar esto al revés cuando reciba un diseño que se indica en píxeles. Entonces:

dp = px / (dpi / 160)

Si está en un dispositivo de 240 ppp, esta relación es 1.5 (como se indicó anteriormente), por lo que esto significa que un icono de 60 píxeles equivale a 40 ppp en la aplicación.

Sin Contextmétodos estáticos elegantes:

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

por DP to Pixel

Crea un valor en dimens.xml

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

Obtenga ese valor pixelcomo:

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

Por lo tanto, puede usar el siguiente formulador para calcular la cantidad correcta de píxeles de una dimensión especificada 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);
}

Para cualquiera que use 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

Hay una utilidad predeterminada en el SDK de Android: http://developer.android.com/reference/android/util/TypedValue.html

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

usando kotlin-extension lo hace mejor

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

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

ACTUALIZAR:

Debido a que displayMetricses parte de los recursos globales compartidos , podemos usarResources.getSystem()

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

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

Esto debería darle la conversión dp a píxeles:

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

Esto debería darle los píxeles de conversión a 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);
}

Probablemente la mejor manera si tiene la dimensión dentro de los valores / dimen es obtener la dimensión directamente del método getDimension (), le devolverá la dimensión ya convertida en valor de píxel.

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

Solo para explicar mejor esto,

getDimension(int resourceId) 

devolverá la dimensión ya convertida a píxel COMO UN FLOTADOR.

getDimensionPixelSize(int resourceId)

devolverá lo mismo pero truncado a int, así que COMO UN INTEGER.

Ver referencia de 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());
}

donde recurso es context.getResources ().

Me gusta esto:

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

depende del contexto, valor de retorno de flotación, método estático

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

Enfoque más elegante usando la función de extensión 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()

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

En caso de que desarrolle una aplicación crítica de rendimiento, considere la siguiente clase optimizada:

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

para convertir píxeles a dp use TypedValue .

Como se menciona en la documentación: Contenedor para un valor de datos con tipo dinámico.

y use el método applyDimension :

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

que convierte un valor de datos complejos desempaquetado que contiene una dimensión a su valor final de coma flotante como el siguiente:

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

Espero que ayude .

Así es como funciona para mí:

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

Puedes hacer lo mismo para el ancho.

Muchas soluciones excelentes arriba. Sin embargo, la mejor solución que encontré es el diseño de Google:

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

Debe usar dp tal como lo haría con los píxeles. Eso es todo lo que son; Mostrar píxeles independientes. Use los mismos números que usaría en una pantalla de densidad media, y el tamaño será mágicamente correcto en una pantalla de alta densidad.

Sin embargo, parece que lo que necesita es la opción fill_parent en su diseño de diseño. Use fill_parent cuando desee que su vista o control se expanda a todo el tamaño restante en el contenedor principal.

PXy DPson diferentes pero similares.

DPes la resolución cuando solo se factoriza el tamaño físico de la pantalla. Cuando lo use DP, escalará su diseño a otras pantallas de tamaño similar con diferentespixel densidades.

Ocasionalmente pixels, sin embargo, realmente desea , y cuando trata con dimensiones en código, siempre está tratando con real pixels, a menos que las convierta.

Entonces, en un dispositivo Android, hdpipantalla de tamaño normal , 800x480 is 533x320en DP(creo). Para convertir DPen pixels /1.5, para volver a convertir *1.5. Esto es solo para el tamaño de una pantalla y dpicambiaría según el diseño. Sin pixelsembargo, nuestros artistas me dan y me convierto DPcon la 1.5ecuación anterior .

Si desea valores enteros , use Math.round () redondeará el flotante al entero más cercano.

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

La mejor respuesta proviene del propio marco de Android: solo use esta igualdad ...

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

(convierte dp a px)

Esto funciona para mí (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;
}