Fórmula px para dp, dp para px android

Estou tentando calcular uma quantidade variável de pixels para densificar pixels independentes e vice-versa.

Essa fórmula (px to dp): dp = (int)(px / (displayMetrics.densityDpi / 160));não funciona em dispositivos pequenos porque é dividida por zero.

Esta é minha fórmula de dp para px:

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

Alguém poderia me dar algumas dicas?

Nota: A solução amplamente usada acima é baseada em displayMetrics.density. No entanto, os documentos explicam que esse valor é um valor arredondado, usado com a tela 'buckets'. Por exemplo. no meu Nexus 10, ele retorna 2, onde o valor real seria 298dpi (real) / 160dpi (padrão) = 1,8625.

Dependendo dos seus requisitos, você pode precisar da transformação exata, que pode ser alcançada assim:

[Editar] Isso não deve ser misturado com a unidade de DP interna do Android, pois isso ainda é baseado nos baldes de tela. Use-o onde desejar uma unidade que renderize o mesmo tamanho real em diferentes dispositivos.

Converter dp em pixel:

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

Converter pixel em dp:

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

Observe que existem propriedades xdpi e ydpi, você pode querer distinguir, mas não consigo imaginar uma exibição sadia em que esses valores sejam muito diferentes.

Resolvi meu problema usando as seguintes fórmulas. Que outras pessoas possam se beneficiar disso.

dp para px:

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

px para dp:

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

px para dp:

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

Maneira eficiente de sempre

DP para Pixel:

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

Pixel para DP:

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

Espero que isso ajude você.

Basta ligar getResources().getDimensionPixelSize(R.dimen.your_dimension)para converter de dpunidades em pixels

Use esta função

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

px = dp * (dpi / 160)

dp = px * (160 / dpi)

Na maioria dos casos, as funções de conversão são chamadas com frequência. Podemos otimizá-lo adicionando memorização. Portanto, ele não calcula sempre que a função é chamada.

Vamos declarar um HashMap que irá armazenar os valores calculados.

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

Uma função que calcula valores de 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;

    }

Uma função de memorização que retorna o valor do HashMap e mantém o registro dos valores anteriores.

A memorização pode ser implementada de diferentes maneiras em Java. Para 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;
    }

O Java 8 suporta a função Lambda :

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

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

Obrigado.

tente isso http://labs.skinkers.com/content/android_dp_px_calculator/

As funções abaixo funcionaram bem para mim em todos os dispositivos.

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

Você pode usar [DisplayMatrics][1]e determinar a densidade da tela. Algo assim:

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

Pelo que me lembro, é melhor usar pisos para compensações e arredondamentos para larguras.

Se você está procurando uma calculadora on-line para converter DP, SP, polegadas, milímetros, pontos ou pixels entre si em densidades de tela diferentes, esta é a ferramenta mais completa que eu conheço .

// para obter em termos de decimal / flutuante

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

Use estas extensões 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()

Sinta-se livre para usar este método que escrevi:

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

A resposta aceita acima não é totalmente precisa. De acordo com as informações obtidas pela inspeção do código fonte do Android:

Resources.getDimension()e getDimensionPixelOffset()/ getDimensionPixelSize()diferem apenas no fato de o primeiro retornar, floatenquanto os dois últimos retornam o mesmo valor arredondado para o valor intapropriado. Para todos eles, o valor de retorno está em pixels brutos.

Todas as três funções são implementedy ligando Resources.getValue()e convertendo assim obtido TypedValueligando TypedValue.complexToDimension(), TypedValue.complexToDimensionPixelOffset()e TypedValue.complexToDimensionPixelSize(), respectivamente.

Portanto, se você deseja obter o valor "bruto" junto com a unidade especificada na fonte XML, chame Resources.getValue()e use os métodos da TypedValueclasse.

com ajuda de outras respostas, escrevi esta função.

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

Aqui está outra maneira de fazer isso usando extensões 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 então pode ser usado assim em qualquer lugar

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

    }

a variação na resposta ct_robs acima, se você estiver usando números inteiros, que não apenas evita a divisão por 0, como também produz um resultado utilizável em dispositivos pequenos:

nos cálculos inteiros envolvendo divisão para maior precisão, multiplique primeiro antes de dividir para reduzir os efeitos de truncamento.

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

5 * 120 = 600 / 160 = 3

ao invés de

5 * (120 / 160 = 0) = 0

se você quiser resultado arredondado, faça isso

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

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