Formuła px do dp, dp do px android

Próbuję obliczyć zmienną liczbę pikseli do niezależnych od gęstości pikseli i odwrotnie.

Ta formuła (px to dp): dp = (int)(px / (displayMetrics.densityDpi / 160));nie działa na małych urządzeniach, ponieważ jest podzielona przez zero.

To jest moja formuła dp do px:

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

Czy ktoś mógłby mi udzielić wskazówek?

Uwaga: szeroko stosowane rozwiązanie powyżej opiera się na displayMetrics.density. Jednak w dokumentacji wyjaśniono, że ta wartość jest wartością zaokrągloną, używaną z „zasobnikami” ekranu. Na przykład. na moim Nexusie 10 zwraca 2, gdzie rzeczywista wartość wynosiłaby 298 dpi (rzeczywista) / 160 dpi (domyślnie) = 1,8625.

W zależności od wymagań możesz potrzebować dokładnej transformacji, którą można osiągnąć w następujący sposób:

[Edytuj] To nie jest przeznaczone do mieszania z wewnętrzną jednostką dp Androida, ponieważ jest to oczywiście nadal oparte na zasobnikach ekranu. Użyj tego, jeśli chcesz, aby jednostka powinna renderować ten sam rzeczywisty rozmiar na różnych urządzeniach.

Konwertuj dp na piksel:

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

Konwertuj piksel na dp:

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

Zauważ, że istnieją właściwości xdpi i ydpi, możesz chcieć je rozróżnić, ale nie wyobrażam sobie rozsądnego wyświetlacza, w którym te wartości znacznie się różnią.

Rozwiązałem swój problem, używając następujących wzorów. Niech skorzystają na tym inni ludzie.

dp do px:

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

px do dp:

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

px do dp:

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

Wydajny sposób zawsze

DP na piksel:

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

Pixel do DP:

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

Mam nadzieję, że to ci pomoże.

Po prostu zadzwoń, getResources().getDimensionPixelSize(R.dimen.your_dimension)aby przekonwertować z dpjednostek na piksele

Użyj tej funkcji

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

px = dp * (dpi / 160)

dp = px * (160 / dpi)

W większości przypadków funkcje konwersji są wywoływane często. Możemy to zoptymalizować dodając zapamiętywanie. Dlatego nie wykonuje obliczeń za każdym razem, gdy wywoływana jest funkcja.

Zadeklarujmy HashMap, który będzie przechowywać obliczone wartości.

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

Funkcja obliczająca wartości pikseli:

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

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

    }

Funkcja zapamiętywania, która zwraca wartość z HashMap i przechowuje zapis poprzednich wartości.

Memoizacja może być implementowana na różne sposoby w Javie. Dla 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 obsługuje funkcję Lambda :

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

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

Dzięki.

spróbuj tego http://labs.skinkers.com/content/android_dp_px_calculator/

Poniższe funkcje działały dobrze dla mnie na różnych urządzeniach.

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

Możesz użyć [DisplayMatrics][1]i określić gęstość ekranu. Coś takiego:

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

O ile dobrze pamiętam, do odsadzeń i zaokrąglania na szerokościach lepiej jest używać podłóg.

Jeśli szukasz kalkulatora online do przeliczania DP, SP, cali, milimetrów, punktów lub pikseli na i między sobą przy różnych gęstościach ekranu, jest to najbardziej kompletne narzędzie, jakie znam .

// do uzyskania wartości Decimal / Float

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

Użyj tych rozszerzeń 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()

Zapraszam do skorzystania z tej metody, którą napisałem:

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

Przyjęta powyżej odpowiedź nie jest w pełni poprawna. Według informacji uzyskanych podczas inspekcji kodu źródłowego Androida:

Resources.getDimension()i getDimensionPixelOffset()/ getDimensionPixelSize()różnią się tylko tym, że pierwszy zwraca, floatpodczas gdy dwa ostatnie zwracają tę samą wartość intodpowiednio zaokrągloną . Dla wszystkich zwracana jest wartość w surowych pikselach.

Wszystkie trzy funkcje są implementowane przez wywołanie Resources.getValue()i konwersję uzyskaną w ten sposób TypedValueprzez wywołanie , odpowiednio TypedValue.complexToDimension(), TypedValue.complexToDimensionPixelOffset()i TypedValue.complexToDimensionPixelSize().

Dlatego jeśli chcesz uzyskać „surową” wartość razem z jednostką określoną w źródle XML, wywołaj Resources.getValue()i użyj metod TypedValueklasy.

z pomocą innych odpowiedzi napisałem tę funkcję.

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

Oto inny sposób na zrobienie tego za pomocą rozszerzeń 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)

a następnie może być używany w ten sposób z dowolnego miejsca

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

    }

odmiana odpowiedzi ct_robs powyżej, jeśli używasz liczb całkowitych, które nie tylko pozwalają uniknąć dzielenia przez 0, ale także dają użyteczny wynik na małych urządzeniach:

w obliczeniach całkowitych obejmujących dzielenie w celu uzyskania największej dokładności należy najpierw pomnożyć przed podzieleniem, aby zredukować efekty obcięcia.

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

5 * 120 = 600 / 160 = 3

zamiast

5 * (120 / 160 = 0) = 0

jeśli chcesz zaokrąglony wynik, zrób to

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

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